gdb/c-lang.c

   1 /* C language support routines for GDB, the GNU debugger.
   2    Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2002, 2003, 2004
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "symtab.h"
  24 #include "gdbtypes.h"
  25 #include "expression.h"
  26 #include "parser-defs.h"
  27 #include "language.h"
  28 #include "c-lang.h"
  29 #include "valprint.h"
  30 #include "macroscope.h"
  31 #include "gdb_assert.h"
  32 #include "charset.h"
  33 #include "gdb_string.h"
  34 #include "demangle.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, char *string, unsigned int length,
  89             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 it's 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                         TARGET_INT_BIT / 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                         TARGET_SHORT_BIT / TARGET_CHAR_BIT,
 252                         0, "short", objfile);
 253       break;
 254     case FT_SIGNED_SHORT:
 255       type = init_type (TYPE_CODE_INT,
 256                         TARGET_SHORT_BIT / TARGET_CHAR_BIT,
 257                         0, "short", objfile);   /* FIXME-fnf */
 258       break;
 259     case FT_UNSIGNED_SHORT:
 260       type = init_type (TYPE_CODE_INT,
 261                         TARGET_SHORT_BIT / TARGET_CHAR_BIT,
 262                         TYPE_FLAG_UNSIGNED, "unsigned short", objfile);
 263       break;
 264     case FT_INTEGER:
 265       type = init_type (TYPE_CODE_INT,
 266                         TARGET_INT_BIT / TARGET_CHAR_BIT,
 267                         0, "int", objfile);
 268       break;
 269     case FT_SIGNED_INTEGER:
 270       type = init_type (TYPE_CODE_INT,
 271                         TARGET_INT_BIT / TARGET_CHAR_BIT,
 272                         0, "int", objfile);     /* FIXME -fnf */
 273       break;
 274     case FT_UNSIGNED_INTEGER:
 275       type = init_type (TYPE_CODE_INT,
 276                         TARGET_INT_BIT / TARGET_CHAR_BIT,
 277                         TYPE_FLAG_UNSIGNED, "unsigned int", objfile);
 278       break;
 279     case FT_LONG:
 280       type = init_type (TYPE_CODE_INT,
 281                         TARGET_LONG_BIT / TARGET_CHAR_BIT,
 282                         0, "long", objfile);
 283       break;
 284     case FT_SIGNED_LONG:
 285       type = init_type (TYPE_CODE_INT,
 286                         TARGET_LONG_BIT / TARGET_CHAR_BIT,
 287                         0, "long", objfile);    /* FIXME -fnf */
 288       break;
 289     case FT_UNSIGNED_LONG:
 290       type = init_type (TYPE_CODE_INT,
 291                         TARGET_LONG_BIT / 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                         TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
 297                         0, "long long", objfile);
 298       break;
 299     case FT_SIGNED_LONG_LONG:
 300       type = init_type (TYPE_CODE_INT,
 301                         TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
 302                         0, "signed long long", objfile);
 303       break;
 304     case FT_UNSIGNED_LONG_LONG:
 305       type = init_type (TYPE_CODE_INT,
 306                         TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
 307                         TYPE_FLAG_UNSIGNED, "unsigned long long", objfile);
 308       break;
 309     case FT_FLOAT:
 310       type = init_type (TYPE_CODE_FLT,
 311                         TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
 312                         0, "float", objfile);
 313       break;
 314     case FT_DBL_PREC_FLOAT:
 315       type = init_type (TYPE_CODE_FLT,
 316                         TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
 317                         0, "double", objfile);
 318       break;
 319     case FT_EXT_PREC_FLOAT:
 320       type = init_type (TYPE_CODE_FLT,
 321                         TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
 322                         0, "long double", objfile);
 323       break;
 324     case FT_COMPLEX:
 325       type = init_type (TYPE_CODE_FLT,
 326                         2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
 327                         0, "complex float", objfile);
 328       TYPE_TARGET_TYPE (type)
 329         = init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
 330                      0, "float", objfile);
 331       break;
 332     case FT_DBL_PREC_COMPLEX:
 333       type = init_type (TYPE_CODE_FLT,
 334                         2 * TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
 335                         0, "complex double", objfile);
 336       TYPE_TARGET_TYPE (type)
 337         = init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
 338                      0, "double", objfile);
 339       break;
 340     case FT_EXT_PREC_COMPLEX:
 341       type = init_type (TYPE_CODE_FLT,
 342                         2 * TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
 343                         0, "complex long double", objfile);
 344       TYPE_TARGET_TYPE (type)
 345         = init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
 346                      0, "long double", objfile);
 347       break;
 348     case FT_TEMPLATE_ARG:
 349       type = init_type (TYPE_CODE_TEMPLATE_ARG,
 350                         0,
 351                         0, "<template arg>", objfile);
 352       break;
 353     }
 354   return (type);
 355 }
 356 \f
 357 /* Preprocessing and parsing C and C++ expressions.  */
 358
 359
 360 /* When we find that lexptr (the global var defined in parse.c) is
 361    pointing at a macro invocation, we expand the invocation, and call
 362    scan_macro_expansion to save the old lexptr here and point lexptr
 363    into the expanded text.  When we reach the end of that, we call
 364    end_macro_expansion to pop back to the value we saved here.  The
 365    macro expansion code promises to return only fully-expanded text,
 366    so we don't need to "push" more than one level.
 367
 368    This is disgusting, of course.  It would be cleaner to do all macro
 369    expansion beforehand, and then hand that to lexptr.  But we don't
 370    really know where the expression ends.  Remember, in a command like
 371
 372      (gdb) break *ADDRESS if CONDITION
 373
 374    we evaluate ADDRESS in the scope of the current frame, but we
 375    evaluate CONDITION in the scope of the breakpoint's location.  So
 376    it's simply wrong to try to macro-expand the whole thing at once.  */
 377 static char *macro_original_text;
 378 static char *macro_expanded_text;
 379
 380
 381 void
 382 scan_macro_expansion (char *expansion)
 383 {
 384   /* We'd better not be trying to push the stack twice.  */
 385   gdb_assert (! macro_original_text);
 386   gdb_assert (! macro_expanded_text);
 387
 388   /* Save the old lexptr value, so we can return to it when we're done
 389      parsing the expanded text.  */
 390   macro_original_text = lexptr;
 391   lexptr = expansion;
 392
 393   /* Save the expanded text, so we can free it when we're finished.  */
 394   macro_expanded_text = expansion;
 395 }
 396
 397
 398 int
 399 scanning_macro_expansion (void)
 400 {
 401   return macro_original_text != 0;
 402 }
 403
 404
 405 void
 406 finished_macro_expansion (void)
 407 {
 408   /* There'd better be something to pop back to, and we better have
 409      saved a pointer to the start of the expanded text.  */
 410   gdb_assert (macro_original_text);
 411   gdb_assert (macro_expanded_text);
 412
 413   /* Pop back to the original text.  */
 414   lexptr = macro_original_text;
 415   macro_original_text = 0;
 416
 417   /* Free the expanded text.  */
 418   xfree (macro_expanded_text);
 419   macro_expanded_text = 0;
 420 }
 421
 422
 423 static void
 424 scan_macro_cleanup (void *dummy)
 425 {
 426   if (macro_original_text)
 427     finished_macro_expansion ();
 428 }
 429
 430
 431 /* We set these global variables before calling c_parse, to tell it
 432    how it to find macro definitions for the expression at hand.  */
 433 macro_lookup_ftype *expression_macro_lookup_func;
 434 void *expression_macro_lookup_baton;
 435
 436
 437 static struct macro_definition *
 438 null_macro_lookup (const char *name, void *baton)
 439 {
 440   return 0;
 441 }
 442
 443
 444 static int
 445 c_preprocess_and_parse (void)
 446 {
 447   /* Set up a lookup function for the macro expander.  */
 448   struct macro_scope *scope = 0;
 449   struct cleanup *back_to = make_cleanup (free_current_contents, &scope);
 450
 451   if (expression_context_block)
 452     scope = sal_macro_scope (find_pc_line (expression_context_pc, 0));
 453   else
 454     scope = default_macro_scope ();
 455
 456   if (scope)
 457     {
 458       expression_macro_lookup_func = standard_macro_lookup;
 459       expression_macro_lookup_baton = (void *) scope;
 460     }
 461   else
 462     {
 463       expression_macro_lookup_func = null_macro_lookup;
 464       expression_macro_lookup_baton = 0;
 465     }
 466
 467   gdb_assert (! macro_original_text);
 468   make_cleanup (scan_macro_cleanup, 0);
 469
 470   {
 471     int result = c_parse ();
 472     do_cleanups (back_to);
 473     return result;
 474   }
 475 }
 476
 477
 478 \f
 479 /* Table mapping opcodes into strings for printing operators
 480    and precedences of the operators.  */
 481
 482 const struct op_print c_op_print_tab[] =
 483 {
 484   {",", BINOP_COMMA, PREC_COMMA, 0},
 485   {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
 486   {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
 487   {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
 488   {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
 489   {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
 490   {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
 491   {"==", BINOP_EQUAL, PREC_EQUAL, 0},
 492   {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
 493   {"<=", BINOP_LEQ, PREC_ORDER, 0},
 494   {">=", BINOP_GEQ, PREC_ORDER, 0},
 495   {">", BINOP_GTR, PREC_ORDER, 0},
 496   {"<", BINOP_LESS, PREC_ORDER, 0},
 497   {">>", BINOP_RSH, PREC_SHIFT, 0},
 498   {"<<", BINOP_LSH, PREC_SHIFT, 0},
 499   {"+", BINOP_ADD, PREC_ADD, 0},
 500   {"-", BINOP_SUB, PREC_ADD, 0},
 501   {"*", BINOP_MUL, PREC_MUL, 0},
 502   {"/", BINOP_DIV, PREC_MUL, 0},
 503   {"%", BINOP_REM, PREC_MUL, 0},
 504   {"@", BINOP_REPEAT, PREC_REPEAT, 0},
 505   {"-", UNOP_NEG, PREC_PREFIX, 0},
 506   {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
 507   {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
 508   {"*", UNOP_IND, PREC_PREFIX, 0},
 509   {"&", UNOP_ADDR, PREC_PREFIX, 0},
 510   {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
 511   {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
 512   {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
 513   {NULL, 0, 0, 0}
 514 };
 515 \f
 516 enum c_primitive_types {
 517   c_primitive_type_int,
 518   c_primitive_type_long,
 519   c_primitive_type_short,
 520   c_primitive_type_char,
 521   c_primitive_type_float,
 522   c_primitive_type_double,
 523   c_primitive_type_void,
 524   c_primitive_type_long_long,
 525   c_primitive_type_signed_char,
 526   c_primitive_type_unsigned_char,
 527   c_primitive_type_unsigned_short,
 528   c_primitive_type_unsigned_int,
 529   c_primitive_type_unsigned_long,
 530   c_primitive_type_unsigned_long_long,
 531   c_primitive_type_long_double,
 532   c_primitive_type_complex,
 533   c_primitive_type_double_complex,
 534   nr_c_primitive_types
 535 };
 536
 537 void
 538 c_language_arch_info (struct gdbarch *gdbarch,
 539                       struct language_arch_info *lai)
 540 {
 541   const struct builtin_type *builtin = builtin_type (gdbarch);
 542   lai->string_char_type = builtin->builtin_char;
 543   lai->primitive_type_vector
 544     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1,
 545                               struct type *);
 546   lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int;
 547   lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long;
 548   lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short;
 549   lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char;
 550   lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float;
 551   lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double;
 552   lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void;
 553   lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long;
 554   lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char;
 555   lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char;
 556   lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short;
 557   lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int;
 558   lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long;
 559   lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long;
 560   lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double;
 561   lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex;
 562   lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex;
 563 };
 564
 565 const struct language_defn c_language_defn =
 566 {
 567   "c",                          /* Language name */
 568   language_c,
 569   NULL,
 570   range_check_off,
 571   type_check_off,
 572   case_sensitive_on,
 573   array_row_major,
 574   &exp_descriptor_standard,
 575   c_preprocess_and_parse,
 576   c_error,
 577   null_post_parser,
 578   c_printchar,                  /* Print a character constant */
 579   c_printstr,                   /* Function to print string constant */
 580   c_emit_char,                  /* Print a single char */
 581   c_create_fundamental_type,    /* Create fundamental type in this language */
 582   c_print_type,                 /* Print a type using appropriate syntax */
 583   c_val_print,                  /* Print a value using appropriate syntax */
 584   c_value_print,                /* Print a top-level value */
 585   NULL,                         /* Language specific skip_trampoline */
 586   NULL,                         /* value_of_this */
 587   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 588   basic_lookup_transparent_type,/* lookup_transparent_type */
 589   NULL,                         /* Language specific symbol demangler */
 590   NULL,                         /* Language specific class_name_from_physname */
 591   c_op_print_tab,               /* expression operators for printing */
 592   1,                            /* c-style arrays */
 593   0,                            /* String lower bound */
 594   NULL,
 595   default_word_break_characters,
 596   c_language_arch_info,
 597   LANG_MAGIC
 598 };
 599
 600 struct type **const (cplus_builtin_types[]) =
 601 {
 602   &builtin_type_int,
 603   &builtin_type_long,
 604   &builtin_type_short,
 605   &builtin_type_char,
 606   &builtin_type_float,
 607   &builtin_type_double,
 608   &builtin_type_void,
 609   &builtin_type_long_long,
 610   &builtin_type_signed_char,
 611   &builtin_type_unsigned_char,
 612   &builtin_type_unsigned_short,
 613   &builtin_type_unsigned_int,
 614   &builtin_type_unsigned_long,
 615   &builtin_type_unsigned_long_long,
 616   &builtin_type_long_double,
 617   &builtin_type_complex,
 618   &builtin_type_double_complex,
 619   &builtin_type_bool,
 620   0
 621 };
 622
 623 const struct language_defn cplus_language_defn =
 624 {
 625   "c++",                        /* Language name */
 626   language_cplus,
 627   cplus_builtin_types,
 628   range_check_off,
 629   type_check_off,
 630   case_sensitive_on,
 631   array_row_major,
 632   &exp_descriptor_standard,
 633   c_preprocess_and_parse,
 634   c_error,
 635   null_post_parser,
 636   c_printchar,                  /* Print a character constant */
 637   c_printstr,                   /* Function to print string constant */
 638   c_emit_char,                  /* Print a single char */
 639   c_create_fundamental_type,    /* Create fundamental type in this language */
 640   c_print_type,                 /* Print a type using appropriate syntax */
 641   c_val_print,                  /* Print a value using appropriate syntax */
 642   c_value_print,                /* Print a top-level value */
 643   NULL,                         /* Language specific skip_trampoline */
 644   value_of_this,                /* value_of_this */
 645   cp_lookup_symbol_nonlocal,    /* lookup_symbol_nonlocal */
 646   cp_lookup_transparent_type,   /* lookup_transparent_type */
 647   cplus_demangle,               /* Language specific symbol demangler */
 648   cp_class_name_from_physname,  /* Language specific class_name_from_physname */
 649   c_op_print_tab,               /* expression operators for printing */
 650   1,                            /* c-style arrays */
 651   0,                            /* String lower bound */
 652   &builtin_type_char,           /* Type of string elements */
 653   default_word_break_characters,
 654   NULL, /* FIXME: la_language_arch_info.  */
 655   LANG_MAGIC
 656 };
 657
 658 const struct language_defn asm_language_defn =
 659 {
 660   "asm",                        /* Language name */
 661   language_asm,
 662   NULL,
 663   range_check_off,
 664   type_check_off,
 665   case_sensitive_on,
 666   array_row_major,
 667   &exp_descriptor_standard,
 668   c_preprocess_and_parse,
 669   c_error,
 670   null_post_parser,
 671   c_printchar,                  /* Print a character constant */
 672   c_printstr,                   /* Function to print string constant */
 673   c_emit_char,                  /* Print a single char */
 674   c_create_fundamental_type,    /* Create fundamental type in this language */
 675   c_print_type,                 /* Print a type using appropriate syntax */
 676   c_val_print,                  /* Print a value using appropriate syntax */
 677   c_value_print,                /* Print a top-level value */
 678   NULL,                         /* Language specific skip_trampoline */
 679   NULL,                         /* value_of_this */
 680   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 681   basic_lookup_transparent_type,/* lookup_transparent_type */
 682   NULL,                         /* Language specific symbol demangler */
 683   NULL,                         /* Language specific class_name_from_physname */
 684   c_op_print_tab,               /* expression operators for printing */
 685   1,                            /* c-style arrays */
 686   0,                            /* String lower bound */
 687   NULL,
 688   default_word_break_characters,
 689   c_language_arch_info, /* FIXME: la_language_arch_info.  */
 690   LANG_MAGIC
 691 };
 692
 693 /* The following language_defn does not represent a real language.
 694    It just provides a minimal support a-la-C that should allow users
 695    to do some simple operations when debugging applications that use
 696    a language currently not supported by GDB.  */
 697
 698 const struct language_defn minimal_language_defn =
 699 {
 700   "minimal",                    /* Language name */
 701   language_minimal,
 702   NULL,
 703   range_check_off,
 704   type_check_off,
 705   case_sensitive_on,
 706   array_row_major,
 707   &exp_descriptor_standard,
 708   c_preprocess_and_parse,
 709   c_error,
 710   null_post_parser,
 711   c_printchar,                  /* Print a character constant */
 712   c_printstr,                   /* Function to print string constant */
 713   c_emit_char,                  /* Print a single char */
 714   c_create_fundamental_type,    /* Create fundamental type in this language */
 715   c_print_type,                 /* Print a type using appropriate syntax */
 716   c_val_print,                  /* Print a value using appropriate syntax */
 717   c_value_print,                /* Print a top-level value */
 718   NULL,                         /* Language specific skip_trampoline */
 719   NULL,                         /* value_of_this */
 720   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 721   basic_lookup_transparent_type,/* lookup_transparent_type */
 722   NULL,                         /* Language specific symbol demangler */
 723   NULL,                         /* Language specific class_name_from_physname */
 724   c_op_print_tab,               /* expression operators for printing */
 725   1,                            /* c-style arrays */
 726   0,                            /* String lower bound */
 727   NULL,
 728   default_word_break_characters,
 729   c_language_arch_info,
 730   LANG_MAGIC
 731 };
 732
 733 void
 734 _initialize_c_language (void)
 735 {
 736   add_language (&c_language_defn);
 737   add_language (&cplus_language_defn);
 738   add_language (&asm_language_defn);
 739   add_language (&minimal_language_defn);
 740 }