contrib/gdb/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 struct type **const (c_builtin_types[]) =
 517 {
 518   &builtin_type_int,
 519   &builtin_type_long,
 520   &builtin_type_short,
 521   &builtin_type_char,
 522   &builtin_type_float,
 523   &builtin_type_double,
 524   &builtin_type_void,
 525   &builtin_type_long_long,
 526   &builtin_type_signed_char,
 527   &builtin_type_unsigned_char,
 528   &builtin_type_unsigned_short,
 529   &builtin_type_unsigned_int,
 530   &builtin_type_unsigned_long,
 531   &builtin_type_unsigned_long_long,
 532   &builtin_type_long_double,
 533   &builtin_type_complex,
 534   &builtin_type_double_complex,
 535   0
 536 };
 537
 538 const struct language_defn c_language_defn =
 539 {
 540   "c",                          /* Language name */
 541   language_c,
 542   c_builtin_types,
 543   range_check_off,
 544   type_check_off,
 545   case_sensitive_on,
 546   &exp_descriptor_standard,
 547   c_preprocess_and_parse,
 548   c_error,
 549   c_printchar,                  /* Print a character constant */
 550   c_printstr,                   /* Function to print string constant */
 551   c_emit_char,                  /* Print a single char */
 552   c_create_fundamental_type,    /* Create fundamental type in this language */
 553   c_print_type,                 /* Print a type using appropriate syntax */
 554   c_val_print,                  /* Print a value using appropriate syntax */
 555   c_value_print,                /* Print a top-level value */
 556   NULL,                         /* Language specific skip_trampoline */
 557   NULL,                         /* value_of_this */
 558   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 559   basic_lookup_transparent_type,/* lookup_transparent_type */
 560   NULL,                         /* Language specific symbol demangler */
 561   {"", "", "", ""},             /* Binary format info */
 562   {"0%lo", "0", "o", ""},       /* Octal format info */
 563   {"%ld", "", "d", ""},         /* Decimal format info */
 564   {"0x%lx", "0x", "x", ""},     /* Hex format info */
 565   c_op_print_tab,               /* expression operators for printing */
 566   1,                            /* c-style arrays */
 567   0,                            /* String lower bound */
 568   &builtin_type_char,           /* Type of string elements */
 569   default_word_break_characters,
 570   LANG_MAGIC
 571 };
 572
 573 struct type **const (cplus_builtin_types[]) =
 574 {
 575   &builtin_type_int,
 576   &builtin_type_long,
 577   &builtin_type_short,
 578   &builtin_type_char,
 579   &builtin_type_float,
 580   &builtin_type_double,
 581   &builtin_type_void,
 582   &builtin_type_long_long,
 583   &builtin_type_signed_char,
 584   &builtin_type_unsigned_char,
 585   &builtin_type_unsigned_short,
 586   &builtin_type_unsigned_int,
 587   &builtin_type_unsigned_long,
 588   &builtin_type_unsigned_long_long,
 589   &builtin_type_long_double,
 590   &builtin_type_complex,
 591   &builtin_type_double_complex,
 592   &builtin_type_bool,
 593   0
 594 };
 595
 596 const struct language_defn cplus_language_defn =
 597 {
 598   "c++",                        /* Language name */
 599   language_cplus,
 600   cplus_builtin_types,
 601   range_check_off,
 602   type_check_off,
 603   case_sensitive_on,
 604   &exp_descriptor_standard,
 605   c_preprocess_and_parse,
 606   c_error,
 607   c_printchar,                  /* Print a character constant */
 608   c_printstr,                   /* Function to print string constant */
 609   c_emit_char,                  /* Print a single char */
 610   c_create_fundamental_type,    /* Create fundamental type in this language */
 611   c_print_type,                 /* Print a type using appropriate syntax */
 612   c_val_print,                  /* Print a value using appropriate syntax */
 613   c_value_print,                /* Print a top-level value */
 614   NULL,                         /* Language specific skip_trampoline */
 615   value_of_this,                /* value_of_this */
 616   cp_lookup_symbol_nonlocal,    /* lookup_symbol_nonlocal */
 617   cp_lookup_transparent_type,   /* lookup_transparent_type */
 618   cplus_demangle,               /* Language specific symbol demangler */
 619   {"", "", "", ""},             /* Binary format info */
 620   {"0%lo", "0", "o", ""},       /* Octal format info */
 621   {"%ld", "", "d", ""},         /* Decimal format info */
 622   {"0x%lx", "0x", "x", ""},     /* Hex format info */
 623   c_op_print_tab,               /* expression operators for printing */
 624   1,                            /* c-style arrays */
 625   0,                            /* String lower bound */
 626   &builtin_type_char,           /* Type of string elements */
 627   default_word_break_characters,
 628   LANG_MAGIC
 629 };
 630
 631 const struct language_defn asm_language_defn =
 632 {
 633   "asm",                        /* Language name */
 634   language_asm,
 635   c_builtin_types,
 636   range_check_off,
 637   type_check_off,
 638   case_sensitive_on,
 639   &exp_descriptor_standard,
 640   c_preprocess_and_parse,
 641   c_error,
 642   c_printchar,                  /* Print a character constant */
 643   c_printstr,                   /* Function to print string constant */
 644   c_emit_char,                  /* Print a single char */
 645   c_create_fundamental_type,    /* Create fundamental type in this language */
 646   c_print_type,                 /* Print a type using appropriate syntax */
 647   c_val_print,                  /* Print a value using appropriate syntax */
 648   c_value_print,                /* Print a top-level value */
 649   NULL,                         /* Language specific skip_trampoline */
 650   NULL,                         /* value_of_this */
 651   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 652   basic_lookup_transparent_type,/* lookup_transparent_type */
 653   NULL,                         /* Language specific symbol demangler */
 654   {"", "", "", ""},             /* Binary format info */
 655   {"0%lo", "0", "o", ""},       /* Octal format info */
 656   {"%ld", "", "d", ""},         /* Decimal format info */
 657   {"0x%lx", "0x", "x", ""},     /* Hex format info */
 658   c_op_print_tab,               /* expression operators for printing */
 659   1,                            /* c-style arrays */
 660   0,                            /* String lower bound */
 661   &builtin_type_char,           /* Type of string elements */
 662   default_word_break_characters,
 663   LANG_MAGIC
 664 };
 665
 666 /* The following language_defn does not represent a real language.
 667    It just provides a minimal support a-la-C that should allow users
 668    to do some simple operations when debugging applications that use
 669    a language currently not supported by GDB.  */
 670
 671 const struct language_defn minimal_language_defn =
 672 {
 673   "minimal",                    /* Language name */
 674   language_minimal,
 675   c_builtin_types,
 676   range_check_off,
 677   type_check_off,
 678   case_sensitive_on,
 679   &exp_descriptor_standard,
 680   c_preprocess_and_parse,
 681   c_error,
 682   c_printchar,                  /* Print a character constant */
 683   c_printstr,                   /* Function to print string constant */
 684   c_emit_char,                  /* Print a single char */
 685   c_create_fundamental_type,    /* Create fundamental type in this language */
 686   c_print_type,                 /* Print a type using appropriate syntax */
 687   c_val_print,                  /* Print a value using appropriate syntax */
 688   c_value_print,                /* Print a top-level value */
 689   NULL,                         /* Language specific skip_trampoline */
 690   NULL,                         /* value_of_this */
 691   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 692   basic_lookup_transparent_type,/* lookup_transparent_type */
 693   NULL,                         /* Language specific symbol demangler */
 694   {"", "", "", ""},             /* Binary format info */
 695   {"0%lo", "0", "o", ""},       /* Octal format info */
 696   {"%ld", "", "d", ""},         /* Decimal format info */
 697   {"0x%lx", "0x", "x", ""},     /* Hex format info */
 698   c_op_print_tab,               /* expression operators for printing */
 699   1,                            /* c-style arrays */
 700   0,                            /* String lower bound */
 701   &builtin_type_char,           /* Type of string elements */
 702   default_word_break_characters,
 703   LANG_MAGIC
 704 };
 705
 706 void
 707 _initialize_c_language (void)
 708 {
 709   add_language (&c_language_defn);
 710   add_language (&cplus_language_defn);
 711   add_language (&asm_language_defn);
 712   add_language (&minimal_language_defn);
 713 }