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