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, 2008 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 \f
 184 /* Preprocessing and parsing C and C++ expressions.  */
 185
 186
 187 /* When we find that lexptr (the global var defined in parse.c) is
 188    pointing at a macro invocation, we expand the invocation, and call
 189    scan_macro_expansion to save the old lexptr here and point lexptr
 190    into the expanded text.  When we reach the end of that, we call
 191    end_macro_expansion to pop back to the value we saved here.  The
 192    macro expansion code promises to return only fully-expanded text,
 193    so we don't need to "push" more than one level.
 194
 195    This is disgusting, of course.  It would be cleaner to do all macro
 196    expansion beforehand, and then hand that to lexptr.  But we don't
 197    really know where the expression ends.  Remember, in a command like
 198
 199      (gdb) break *ADDRESS if CONDITION
 200
 201    we evaluate ADDRESS in the scope of the current frame, but we
 202    evaluate CONDITION in the scope of the breakpoint's location.  So
 203    it's simply wrong to try to macro-expand the whole thing at once.  */
 204 static char *macro_original_text;
 205 static char *macro_expanded_text;
 206
 207
 208 void
 209 scan_macro_expansion (char *expansion)
 210 {
 211   /* We'd better not be trying to push the stack twice.  */
 212   gdb_assert (! macro_original_text);
 213   gdb_assert (! macro_expanded_text);
 214
 215   /* Save the old lexptr value, so we can return to it when we're done
 216      parsing the expanded text.  */
 217   macro_original_text = lexptr;
 218   lexptr = expansion;
 219
 220   /* Save the expanded text, so we can free it when we're finished.  */
 221   macro_expanded_text = expansion;
 222 }
 223
 224
 225 int
 226 scanning_macro_expansion (void)
 227 {
 228   return macro_original_text != 0;
 229 }
 230
 231
 232 void
 233 finished_macro_expansion (void)
 234 {
 235   /* There'd better be something to pop back to, and we better have
 236      saved a pointer to the start of the expanded text.  */
 237   gdb_assert (macro_original_text);
 238   gdb_assert (macro_expanded_text);
 239
 240   /* Pop back to the original text.  */
 241   lexptr = macro_original_text;
 242   macro_original_text = 0;
 243
 244   /* Free the expanded text.  */
 245   xfree (macro_expanded_text);
 246   macro_expanded_text = 0;
 247 }
 248
 249
 250 static void
 251 scan_macro_cleanup (void *dummy)
 252 {
 253   if (macro_original_text)
 254     finished_macro_expansion ();
 255 }
 256
 257
 258 /* We set these global variables before calling c_parse, to tell it
 259    how it to find macro definitions for the expression at hand.  */
 260 macro_lookup_ftype *expression_macro_lookup_func;
 261 void *expression_macro_lookup_baton;
 262
 263
 264 static int
 265 c_preprocess_and_parse (void)
 266 {
 267   /* Set up a lookup function for the macro expander.  */
 268   struct macro_scope *scope = 0;
 269   struct cleanup *back_to = make_cleanup (free_current_contents, &scope);
 270
 271   if (expression_context_block)
 272     scope = sal_macro_scope (find_pc_line (expression_context_pc, 0));
 273   else
 274     scope = default_macro_scope ();
 275   if (! scope)
 276     scope = user_macro_scope ();
 277
 278   expression_macro_lookup_func = standard_macro_lookup;
 279   expression_macro_lookup_baton = (void *) scope;
 280
 281   gdb_assert (! macro_original_text);
 282   make_cleanup (scan_macro_cleanup, 0);
 283
 284   {
 285     int result = c_parse ();
 286     do_cleanups (back_to);
 287     return result;
 288   }
 289 }
 290
 291
 292 \f
 293 /* Table mapping opcodes into strings for printing operators
 294    and precedences of the operators.  */
 295
 296 const struct op_print c_op_print_tab[] =
 297 {
 298   {",", BINOP_COMMA, PREC_COMMA, 0},
 299   {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
 300   {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
 301   {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
 302   {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
 303   {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
 304   {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
 305   {"==", BINOP_EQUAL, PREC_EQUAL, 0},
 306   {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
 307   {"<=", BINOP_LEQ, PREC_ORDER, 0},
 308   {">=", BINOP_GEQ, PREC_ORDER, 0},
 309   {">", BINOP_GTR, PREC_ORDER, 0},
 310   {"<", BINOP_LESS, PREC_ORDER, 0},
 311   {">>", BINOP_RSH, PREC_SHIFT, 0},
 312   {"<<", BINOP_LSH, PREC_SHIFT, 0},
 313   {"+", BINOP_ADD, PREC_ADD, 0},
 314   {"-", BINOP_SUB, PREC_ADD, 0},
 315   {"*", BINOP_MUL, PREC_MUL, 0},
 316   {"/", BINOP_DIV, PREC_MUL, 0},
 317   {"%", BINOP_REM, PREC_MUL, 0},
 318   {"@", BINOP_REPEAT, PREC_REPEAT, 0},
 319   {"-", UNOP_NEG, PREC_PREFIX, 0},
 320   {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
 321   {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
 322   {"*", UNOP_IND, PREC_PREFIX, 0},
 323   {"&", UNOP_ADDR, PREC_PREFIX, 0},
 324   {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
 325   {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
 326   {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
 327   {NULL, 0, 0, 0}
 328 };
 329 \f
 330 enum c_primitive_types {
 331   c_primitive_type_int,
 332   c_primitive_type_long,
 333   c_primitive_type_short,
 334   c_primitive_type_char,
 335   c_primitive_type_float,
 336   c_primitive_type_double,
 337   c_primitive_type_void,
 338   c_primitive_type_long_long,
 339   c_primitive_type_signed_char,
 340   c_primitive_type_unsigned_char,
 341   c_primitive_type_unsigned_short,
 342   c_primitive_type_unsigned_int,
 343   c_primitive_type_unsigned_long,
 344   c_primitive_type_unsigned_long_long,
 345   c_primitive_type_long_double,
 346   c_primitive_type_complex,
 347   c_primitive_type_double_complex,
 348   c_primitive_type_decfloat,
 349   c_primitive_type_decdouble,
 350   c_primitive_type_declong,
 351   nr_c_primitive_types
 352 };
 353
 354 void
 355 c_language_arch_info (struct gdbarch *gdbarch,
 356                       struct language_arch_info *lai)
 357 {
 358   const struct builtin_type *builtin = builtin_type (gdbarch);
 359   lai->string_char_type = builtin->builtin_char;
 360   lai->primitive_type_vector
 361     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1,
 362                               struct type *);
 363   lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int;
 364   lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long;
 365   lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short;
 366   lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char;
 367   lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float;
 368   lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double;
 369   lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void;
 370   lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long;
 371   lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char;
 372   lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char;
 373   lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short;
 374   lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int;
 375   lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long;
 376   lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long;
 377   lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double;
 378   lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex;
 379   lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex;
 380   lai->primitive_type_vector [c_primitive_type_decfloat] = builtin->builtin_decfloat;
 381   lai->primitive_type_vector [c_primitive_type_decdouble] = builtin->builtin_decdouble;
 382   lai->primitive_type_vector [c_primitive_type_declong] = builtin->builtin_declong;
 383
 384   lai->bool_type_default = builtin->builtin_int;
 385 }
 386
 387 const struct language_defn c_language_defn =
 388 {
 389   "c",                          /* Language name */
 390   language_c,
 391   range_check_off,
 392   type_check_off,
 393   case_sensitive_on,
 394   array_row_major,
 395   macro_expansion_c,
 396   &exp_descriptor_standard,
 397   c_preprocess_and_parse,
 398   c_error,
 399   null_post_parser,
 400   c_printchar,                  /* Print a character constant */
 401   c_printstr,                   /* Function to print string constant */
 402   c_emit_char,                  /* Print a single char */
 403   c_print_type,                 /* Print a type using appropriate syntax */
 404   c_print_typedef,              /* Print a typedef using appropriate syntax */
 405   c_val_print,                  /* Print a value using appropriate syntax */
 406   c_value_print,                /* Print a top-level value */
 407   NULL,                         /* Language specific skip_trampoline */
 408   NULL,                         /* name_of_this */
 409   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 410   basic_lookup_transparent_type,/* lookup_transparent_type */
 411   NULL,                         /* Language specific symbol demangler */
 412   NULL,                         /* Language specific class_name_from_physname */
 413   c_op_print_tab,               /* expression operators for printing */
 414   1,                            /* c-style arrays */
 415   0,                            /* String lower bound */
 416   default_word_break_characters,
 417   default_make_symbol_completion_list,
 418   c_language_arch_info,
 419   default_print_array_index,
 420   default_pass_by_reference,
 421   LANG_MAGIC
 422 };
 423
 424 enum cplus_primitive_types {
 425   cplus_primitive_type_int,
 426   cplus_primitive_type_long,
 427   cplus_primitive_type_short,
 428   cplus_primitive_type_char,
 429   cplus_primitive_type_float,
 430   cplus_primitive_type_double,
 431   cplus_primitive_type_void,
 432   cplus_primitive_type_long_long,
 433   cplus_primitive_type_signed_char,
 434   cplus_primitive_type_unsigned_char,
 435   cplus_primitive_type_unsigned_short,
 436   cplus_primitive_type_unsigned_int,
 437   cplus_primitive_type_unsigned_long,
 438   cplus_primitive_type_unsigned_long_long,
 439   cplus_primitive_type_long_double,
 440   cplus_primitive_type_complex,
 441   cplus_primitive_type_double_complex,
 442   cplus_primitive_type_bool,
 443   cplus_primitive_type_decfloat,
 444   cplus_primitive_type_decdouble,
 445   cplus_primitive_type_declong,
 446   nr_cplus_primitive_types
 447 };
 448
 449 static void
 450 cplus_language_arch_info (struct gdbarch *gdbarch,
 451                           struct language_arch_info *lai)
 452 {
 453   const struct builtin_type *builtin = builtin_type (gdbarch);
 454   lai->string_char_type = builtin->builtin_char;
 455   lai->primitive_type_vector
 456     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1,
 457                               struct type *);
 458   lai->primitive_type_vector [cplus_primitive_type_int]
 459     = builtin->builtin_int;
 460   lai->primitive_type_vector [cplus_primitive_type_long]
 461     = builtin->builtin_long;
 462   lai->primitive_type_vector [cplus_primitive_type_short]
 463     = builtin->builtin_short;
 464   lai->primitive_type_vector [cplus_primitive_type_char]
 465     = builtin->builtin_char;
 466   lai->primitive_type_vector [cplus_primitive_type_float]
 467     = builtin->builtin_float;
 468   lai->primitive_type_vector [cplus_primitive_type_double]
 469     = builtin->builtin_double;
 470   lai->primitive_type_vector [cplus_primitive_type_void]
 471     = builtin->builtin_void;
 472   lai->primitive_type_vector [cplus_primitive_type_long_long]
 473     = builtin->builtin_long_long;
 474   lai->primitive_type_vector [cplus_primitive_type_signed_char]
 475     = builtin->builtin_signed_char;
 476   lai->primitive_type_vector [cplus_primitive_type_unsigned_char]
 477     = builtin->builtin_unsigned_char;
 478   lai->primitive_type_vector [cplus_primitive_type_unsigned_short]
 479     = builtin->builtin_unsigned_short;
 480   lai->primitive_type_vector [cplus_primitive_type_unsigned_int]
 481     = builtin->builtin_unsigned_int;
 482   lai->primitive_type_vector [cplus_primitive_type_unsigned_long]
 483     = builtin->builtin_unsigned_long;
 484   lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long]
 485     = builtin->builtin_unsigned_long_long;
 486   lai->primitive_type_vector [cplus_primitive_type_long_double]
 487     = builtin->builtin_long_double;
 488   lai->primitive_type_vector [cplus_primitive_type_complex]
 489     = builtin->builtin_complex;
 490   lai->primitive_type_vector [cplus_primitive_type_double_complex]
 491     = builtin->builtin_double_complex;
 492   lai->primitive_type_vector [cplus_primitive_type_bool]
 493     = builtin->builtin_bool;
 494   lai->primitive_type_vector [cplus_primitive_type_decfloat]
 495     = builtin->builtin_decfloat;
 496   lai->primitive_type_vector [cplus_primitive_type_decdouble]
 497     = builtin->builtin_decdouble;
 498   lai->primitive_type_vector [cplus_primitive_type_declong]
 499     = builtin->builtin_declong;
 500
 501   lai->bool_type_symbol = "bool";
 502   lai->bool_type_default = builtin->builtin_bool;
 503 }
 504
 505 const struct language_defn cplus_language_defn =
 506 {
 507   "c++",                        /* Language name */
 508   language_cplus,
 509   range_check_off,
 510   type_check_off,
 511   case_sensitive_on,
 512   array_row_major,
 513   macro_expansion_c,
 514   &exp_descriptor_standard,
 515   c_preprocess_and_parse,
 516   c_error,
 517   null_post_parser,
 518   c_printchar,                  /* Print a character constant */
 519   c_printstr,                   /* Function to print string constant */
 520   c_emit_char,                  /* Print a single char */
 521   c_print_type,                 /* Print a type using appropriate syntax */
 522   c_print_typedef,              /* Print a typedef using appropriate syntax */
 523   c_val_print,                  /* Print a value using appropriate syntax */
 524   c_value_print,                /* Print a top-level value */
 525   cplus_skip_trampoline,        /* Language specific skip_trampoline */
 526   "this",                       /* name_of_this */
 527   cp_lookup_symbol_nonlocal,    /* lookup_symbol_nonlocal */
 528   cp_lookup_transparent_type,   /* lookup_transparent_type */
 529   cplus_demangle,               /* Language specific symbol demangler */
 530   cp_class_name_from_physname,  /* Language specific class_name_from_physname */
 531   c_op_print_tab,               /* expression operators for printing */
 532   1,                            /* c-style arrays */
 533   0,                            /* String lower bound */
 534   default_word_break_characters,
 535   default_make_symbol_completion_list,
 536   cplus_language_arch_info,
 537   default_print_array_index,
 538   cp_pass_by_reference,
 539   LANG_MAGIC
 540 };
 541
 542 const struct language_defn asm_language_defn =
 543 {
 544   "asm",                        /* Language name */
 545   language_asm,
 546   range_check_off,
 547   type_check_off,
 548   case_sensitive_on,
 549   array_row_major,
 550   macro_expansion_c,
 551   &exp_descriptor_standard,
 552   c_preprocess_and_parse,
 553   c_error,
 554   null_post_parser,
 555   c_printchar,                  /* Print a character constant */
 556   c_printstr,                   /* Function to print string constant */
 557   c_emit_char,                  /* Print a single char */
 558   c_print_type,                 /* Print a type using appropriate syntax */
 559   c_print_typedef,              /* Print a typedef using appropriate syntax */
 560   c_val_print,                  /* Print a value using appropriate syntax */
 561   c_value_print,                /* Print a top-level value */
 562   NULL,                         /* Language specific skip_trampoline */
 563   NULL,                         /* name_of_this */
 564   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 565   basic_lookup_transparent_type,/* lookup_transparent_type */
 566   NULL,                         /* Language specific symbol demangler */
 567   NULL,                         /* Language specific class_name_from_physname */
 568   c_op_print_tab,               /* expression operators for printing */
 569   1,                            /* c-style arrays */
 570   0,                            /* String lower bound */
 571   default_word_break_characters,
 572   default_make_symbol_completion_list,
 573   c_language_arch_info, /* FIXME: la_language_arch_info.  */
 574   default_print_array_index,
 575   default_pass_by_reference,
 576   LANG_MAGIC
 577 };
 578
 579 /* The following language_defn does not represent a real language.
 580    It just provides a minimal support a-la-C that should allow users
 581    to do some simple operations when debugging applications that use
 582    a language currently not supported by GDB.  */
 583
 584 const struct language_defn minimal_language_defn =
 585 {
 586   "minimal",                    /* Language name */
 587   language_minimal,
 588   range_check_off,
 589   type_check_off,
 590   case_sensitive_on,
 591   array_row_major,
 592   macro_expansion_c,
 593   &exp_descriptor_standard,
 594   c_preprocess_and_parse,
 595   c_error,
 596   null_post_parser,
 597   c_printchar,                  /* Print a character constant */
 598   c_printstr,                   /* Function to print string constant */
 599   c_emit_char,                  /* Print a single char */
 600   c_print_type,                 /* Print a type using appropriate syntax */
 601   c_print_typedef,              /* Print a typedef using appropriate syntax */
 602   c_val_print,                  /* Print a value using appropriate syntax */
 603   c_value_print,                /* Print a top-level value */
 604   NULL,                         /* Language specific skip_trampoline */
 605   NULL,                         /* name_of_this */
 606   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 607   basic_lookup_transparent_type,/* lookup_transparent_type */
 608   NULL,                         /* Language specific symbol demangler */
 609   NULL,                         /* Language specific class_name_from_physname */
 610   c_op_print_tab,               /* expression operators for printing */
 611   1,                            /* c-style arrays */
 612   0,                            /* String lower bound */
 613   default_word_break_characters,
 614   default_make_symbol_completion_list,
 615   c_language_arch_info,
 616   default_print_array_index,
 617   default_pass_by_reference,
 618   LANG_MAGIC
 619 };
 620
 621 void
 622 _initialize_c_language (void)
 623 {
 624   add_language (&c_language_defn);
 625   add_language (&cplus_language_defn);
 626   add_language (&asm_language_defn);
 627   add_language (&minimal_language_defn);
 628 }