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, 2009 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 #include "gdb_obstack.h"
  37 #include <ctype.h>
  38
  39 extern void _initialize_c_language (void);
  40
  41 /* Given a C string type, STR_TYPE, return the corresponding target
  42    character set name.  */
  43
  44 static const char *
  45 charset_for_string_type (enum c_string_type str_type)
  46 {
  47   switch (str_type & ~C_CHAR)
  48     {
  49     case C_STRING:
  50       return target_charset ();
  51     case C_WIDE_STRING:
  52       return target_wide_charset ();
  53     case C_STRING_16:
  54       /* FIXME: UCS-2 is not always correct.  */
  55       if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
  56         return "UCS-2BE";
  57       else
  58         return "UCS-2LE";
  59     case C_STRING_32:
  60       /* FIXME: UCS-4 is not always correct.  */
  61       if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
  62         return "UCS-4BE";
  63       else
  64         return "UCS-4LE";
  65     }
  66   internal_error (__FILE__, __LINE__, "unhandled c_string_type");
  67 }
  68
  69 /* Classify ELTTYPE according to what kind of character it is.  Return
  70    the enum constant representing the character type.  Also set
  71    *ENCODING to the name of the character set to use when converting
  72    characters of this type to the host character set.  */
  73
  74 static enum c_string_type
  75 classify_type (struct type *elttype, const char **encoding)
  76 {
  77   struct type *saved_type;
  78   enum c_string_type result;
  79
  80   /* We do one or two passes -- one on ELTTYPE, and then maybe a
  81      second one on a typedef target.  */
  82   do
  83     {
  84       char *name = TYPE_NAME (elttype);
  85
  86       if (TYPE_CODE (elttype) == TYPE_CODE_CHAR || !name)
  87         {
  88           result = C_CHAR;
  89           goto done;
  90         }
  91
  92       if (!strcmp (name, "wchar_t"))
  93         {
  94           result = C_WIDE_CHAR;
  95           goto done;
  96         }
  97
  98       if (!strcmp (name, "char16_t"))
  99         {
 100           result = C_CHAR_16;
 101           goto done;
 102         }
 103
 104       if (!strcmp (name, "char32_t"))
 105         {
 106           result = C_CHAR_32;
 107           goto done;
 108         }
 109
 110       saved_type = elttype;
 111       CHECK_TYPEDEF (elttype);
 112     }
 113   while (elttype != saved_type);
 114
 115   /* Punt.  */
 116   result = C_CHAR;
 117
 118  done:
 119   *encoding = charset_for_string_type (result);
 120   return result;
 121 }
 122
 123 /* Return true if print_wchar can display W without resorting to a
 124    numeric escape, false otherwise.  */
 125
 126 static int
 127 wchar_printable (gdb_wchar_t w)
 128 {
 129   return (gdb_iswprint (w)
 130           || w == LCST ('\a') || w == LCST ('\b')
 131           || w == LCST ('\f') || w == LCST ('\n')
 132           || w == LCST ('\r') || w == LCST ('\t')
 133           || w == LCST ('\v'));
 134 }
 135
 136 /* A helper function that converts the contents of STRING to wide
 137    characters and then appends them to OUTPUT.  */
 138
 139 static void
 140 append_string_as_wide (const char *string, struct obstack *output)
 141 {
 142   for (; *string; ++string)
 143     {
 144       gdb_wchar_t w = gdb_btowc (*string);
 145       obstack_grow (output, &w, sizeof (gdb_wchar_t));
 146     }
 147 }
 148
 149 /* Print a wide character W to OUTPUT.  ORIG is a pointer to the
 150    original (target) bytes representing the character, ORIG_LEN is the
 151    number of valid bytes.  WIDTH is the number of bytes in a base
 152    characters of the type.  OUTPUT is an obstack to which wide
 153    characters are emitted.  QUOTER is a (narrow) character indicating
 154    the style of quotes surrounding the character to be printed.
 155    NEED_ESCAPE is an in/out flag which is used to track numeric
 156    escapes across calls.  */
 157
 158 static void
 159 print_wchar (gdb_wint_t w, const gdb_byte *orig, int orig_len,
 160              int width, struct obstack *output, int quoter,
 161              int *need_escapep)
 162 {
 163   int need_escape = *need_escapep;
 164   *need_escapep = 0;
 165   if (gdb_iswprint (w) && (!need_escape || (!gdb_iswdigit (w)
 166                                             && w != LCST ('8')
 167                                             && w != LCST ('9'))))
 168     {
 169       gdb_wchar_t wchar = w;
 170
 171       if (w == gdb_btowc (quoter) || w == LCST ('\\'))
 172         obstack_grow_wstr (output, LCST ("\\"));
 173       obstack_grow (output, &wchar, sizeof (gdb_wchar_t));
 174     }
 175   else
 176     {
 177       switch (w)
 178         {
 179         case LCST ('\a'):
 180           obstack_grow_wstr (output, LCST ("\\a"));
 181           break;
 182         case LCST ('\b'):
 183           obstack_grow_wstr (output, LCST ("\\b"));
 184           break;
 185         case LCST ('\f'):
 186           obstack_grow_wstr (output, LCST ("\\f"));
 187           break;
 188         case LCST ('\n'):
 189           obstack_grow_wstr (output, LCST ("\\n"));
 190           break;
 191         case LCST ('\r'):
 192           obstack_grow_wstr (output, LCST ("\\r"));
 193           break;
 194         case LCST ('\t'):
 195           obstack_grow_wstr (output, LCST ("\\t"));
 196           break;
 197         case LCST ('\v'):
 198           obstack_grow_wstr (output, LCST ("\\v"));
 199           break;
 200         default:
 201           {
 202             int i;
 203
 204             for (i = 0; i + width <= orig_len; i += width)
 205               {
 206                 char octal[30];
 207                 ULONGEST value = extract_unsigned_integer (&orig[i], width);
 208                 sprintf (octal, "\\%lo", (long) value);
 209                 append_string_as_wide (octal, output);
 210               }
 211             /* If we somehow have extra bytes, print them now.  */
 212             while (i < orig_len)
 213               {
 214                 char octal[5];
 215                 sprintf (octal, "\\%.3o", orig[i] & 0xff);
 216                 append_string_as_wide (octal, output);
 217                 ++i;
 218               }
 219
 220             *need_escapep = 1;
 221           }
 222           break;
 223         }
 224     }
 225 }
 226
 227 /* Print the character C on STREAM as part of the contents of a literal
 228    string whose delimiter is QUOTER.  Note that that format for printing
 229    characters and strings is language specific. */
 230
 231 static void
 232 c_emit_char (int c, struct type *type, struct ui_file *stream, int quoter)
 233 {
 234   struct obstack wchar_buf, output;
 235   struct cleanup *cleanups;
 236   const char *encoding;
 237   gdb_byte *buf;
 238   struct wchar_iterator *iter;
 239   int need_escape = 0;
 240
 241   classify_type (type, &encoding);
 242
 243   buf = alloca (TYPE_LENGTH (type));
 244   pack_long (buf, type, c);
 245
 246   iter = make_wchar_iterator (buf, TYPE_LENGTH (type), encoding,
 247                               TYPE_LENGTH (type));
 248   cleanups = make_cleanup_wchar_iterator (iter);
 249
 250   /* This holds the printable form of the wchar_t data.  */
 251   obstack_init (&wchar_buf);
 252   make_cleanup_obstack_free (&wchar_buf);
 253
 254   while (1)
 255     {
 256       int num_chars;
 257       gdb_wchar_t *chars;
 258       const gdb_byte *buf;
 259       size_t buflen;
 260       int print_escape = 1;
 261       enum wchar_iterate_result result;
 262
 263       num_chars = wchar_iterate (iter, &result, &chars, &buf, &buflen);
 264       if (num_chars < 0)
 265         break;
 266       if (num_chars > 0)
 267         {
 268           /* If all characters are printable, print them.  Otherwise,
 269              we're going to have to print an escape sequence.  We
 270              check all characters because we want to print the target
 271              bytes in the escape sequence, and we don't know character
 272              boundaries there.  */
 273           int i;
 274
 275           print_escape = 0;
 276           for (i = 0; i < num_chars; ++i)
 277             if (!wchar_printable (chars[i]))
 278               {
 279                 print_escape = 1;
 280                 break;
 281               }
 282
 283           if (!print_escape)
 284             {
 285               for (i = 0; i < num_chars; ++i)
 286                 print_wchar (chars[i], buf, buflen, TYPE_LENGTH (type),
 287                              &wchar_buf, quoter, &need_escape);
 288             }
 289         }
 290
 291       /* This handles the NUM_CHARS == 0 case as well.  */
 292       if (print_escape)
 293         print_wchar (gdb_WEOF, buf, buflen, TYPE_LENGTH (type), &wchar_buf,
 294                      quoter, &need_escape);
 295     }
 296
 297   /* The output in the host encoding.  */
 298   obstack_init (&output);
 299   make_cleanup_obstack_free (&output);
 300
 301   convert_between_encodings (INTERMEDIATE_ENCODING, host_charset (),
 302                              obstack_base (&wchar_buf),
 303                              obstack_object_size (&wchar_buf),
 304                              1, &output, translit_char);
 305   obstack_1grow (&output, '\0');
 306
 307   fputs_filtered (obstack_base (&output), stream);
 308
 309   do_cleanups (cleanups);
 310 }
 311
 312 void
 313 c_printchar (int c, struct type *type, struct ui_file *stream)
 314 {
 315   enum c_string_type str_type;
 316   const char *encoding;
 317
 318   str_type = classify_type (type, &encoding);
 319   switch (str_type)
 320     {
 321     case C_CHAR:
 322       break;
 323     case C_WIDE_CHAR:
 324       fputc_filtered ('L', stream);
 325       break;
 326     case C_CHAR_16:
 327       fputc_filtered ('u', stream);
 328       break;
 329     case C_CHAR_32:
 330       fputc_filtered ('U', stream);
 331       break;
 332     }
 333
 334   fputc_filtered ('\'', stream);
 335   LA_EMIT_CHAR (c, type, stream, '\'');
 336   fputc_filtered ('\'', stream);
 337 }
 338
 339 /* Print the character string STRING, printing at most LENGTH characters.
 340    LENGTH is -1 if the string is nul terminated.  Each character is WIDTH bytes
 341    long.  Printing stops early if the number hits print_max; repeat counts are
 342    printed as appropriate.  Print ellipses at the end if we had to stop before
 343    printing LENGTH characters, or if FORCE_ELLIPSES.  */
 344
 345 void
 346 c_printstr (struct ui_file *stream, struct type *type, const gdb_byte *string,
 347             unsigned int length, int force_ellipses,
 348             const struct value_print_options *options)
 349 {
 350   unsigned int i;
 351   unsigned int things_printed = 0;
 352   int in_quotes = 0;
 353   int need_comma = 0;
 354   int width = TYPE_LENGTH (type);
 355   struct obstack wchar_buf, output;
 356   struct cleanup *cleanup;
 357   enum c_string_type str_type;
 358   const char *encoding;
 359   struct wchar_iterator *iter;
 360   int finished = 0;
 361   int need_escape = 0;
 362
 363   /* If the string was not truncated due to `set print elements', and
 364      the last byte of it is a null, we don't print that, in traditional C
 365      style.  */
 366   if (!force_ellipses
 367       && length > 0
 368       && (extract_unsigned_integer (string + (length - 1) * width, width) == 0))
 369     length--;
 370
 371   str_type = classify_type (type, &encoding) & ~C_CHAR;
 372   switch (str_type)
 373     {
 374     case C_STRING:
 375       break;
 376     case C_WIDE_STRING:
 377       fputs_filtered ("L", stream);
 378       break;
 379     case C_STRING_16:
 380       fputs_filtered ("u", stream);
 381       break;
 382     case C_STRING_32:
 383       fputs_filtered ("U", stream);
 384       break;
 385     }
 386
 387   if (length == 0)
 388     {
 389       fputs_filtered ("\"\"", stream);
 390       return;
 391     }
 392
 393   if (length == -1)
 394     {
 395       unsigned long current_char = 1;
 396       for (i = 0; current_char; ++i)
 397         {
 398           QUIT;
 399           current_char = extract_unsigned_integer (string + i * width, width);
 400         }
 401       length = i;
 402     }
 403
 404   /* Arrange to iterate over the characters, in wchar_t form.  */
 405   iter = make_wchar_iterator (string, length * width, encoding, width);
 406   cleanup = make_cleanup_wchar_iterator (iter);
 407
 408   /* WCHAR_BUF is the obstack we use to represent the string in
 409      wchar_t form.  */
 410   obstack_init (&wchar_buf);
 411   make_cleanup_obstack_free (&wchar_buf);
 412
 413   while (!finished && things_printed < options->print_max)
 414     {
 415       int num_chars;
 416       enum wchar_iterate_result result;
 417       gdb_wchar_t *chars;
 418       const gdb_byte *buf;
 419       size_t buflen;
 420
 421       QUIT;
 422
 423       if (need_comma)
 424         {
 425           obstack_grow_wstr (&wchar_buf, LCST (", "));
 426           need_comma = 0;
 427         }
 428
 429       num_chars = wchar_iterate (iter, &result, &chars, &buf, &buflen);
 430       /* We only look at repetitions when we were able to convert a
 431          single character in isolation.  This makes the code simpler
 432          and probably does the sensible thing in the majority of
 433          cases.  */
 434       while (num_chars == 1)
 435         {
 436           /* Count the number of repetitions.  */
 437           unsigned int reps = 0;
 438           gdb_wchar_t current_char = chars[0];
 439           const gdb_byte *orig_buf = buf;
 440           int orig_len = buflen;
 441
 442           if (need_comma)
 443             {
 444               obstack_grow_wstr (&wchar_buf, LCST (", "));
 445               need_comma = 0;
 446             }
 447
 448           while (num_chars == 1 && current_char == chars[0])
 449             {
 450               num_chars = wchar_iterate (iter, &result, &chars, &buf, &buflen);
 451               ++reps;
 452             }
 453
 454           /* Emit CURRENT_CHAR according to the repetition count and
 455              options.  */
 456           if (reps > options->repeat_count_threshold)
 457             {
 458               if (in_quotes)
 459                 {
 460                   if (options->inspect_it)
 461                     obstack_grow_wstr (&wchar_buf, LCST ("\\\", "));
 462                   else
 463                     obstack_grow_wstr (&wchar_buf, LCST ("\", "));
 464                   in_quotes = 0;
 465                 }
 466               obstack_grow_wstr (&wchar_buf, LCST ("'"));
 467               need_escape = 0;
 468               print_wchar (current_char, orig_buf, orig_len, width,
 469                            &wchar_buf, '\'', &need_escape);
 470               obstack_grow_wstr (&wchar_buf, LCST ("'"));
 471               {
 472                 /* Painful gyrations.  */
 473                 int j;
 474                 char *s = xstrprintf (_(" <repeats %u times>"), reps);
 475                 for (j = 0; s[j]; ++j)
 476                   {
 477                     gdb_wchar_t w = gdb_btowc (s[j]);
 478                     obstack_grow (&wchar_buf, &w, sizeof (gdb_wchar_t));
 479                   }
 480                 xfree (s);
 481               }
 482               things_printed += options->repeat_count_threshold;
 483               need_comma = 1;
 484             }
 485           else
 486             {
 487               /* Saw the character one or more times, but fewer than
 488                  the repetition threshold.  */
 489               if (!in_quotes)
 490                 {
 491                   if (options->inspect_it)
 492                     obstack_grow_wstr (&wchar_buf, LCST ("\\\""));
 493                   else
 494                     obstack_grow_wstr (&wchar_buf, LCST ("\""));
 495                   in_quotes = 1;
 496                   need_escape = 0;
 497                 }
 498
 499               while (reps-- > 0)
 500                 {
 501                   print_wchar (current_char, orig_buf, orig_len, width,
 502                                &wchar_buf, '"', &need_escape);
 503                   ++things_printed;
 504                 }
 505             }
 506         }
 507
 508       /* NUM_CHARS and the other outputs from wchar_iterate are valid
 509          here regardless of which branch was taken above.  */
 510       if (num_chars < 0)
 511         {
 512           /* Hit EOF.  */
 513           finished = 1;
 514           break;
 515         }
 516
 517       switch (result)
 518         {
 519         case wchar_iterate_invalid:
 520           if (!in_quotes)
 521             {
 522               if (options->inspect_it)
 523                 obstack_grow_wstr (&wchar_buf, LCST ("\\\""));
 524               else
 525                 obstack_grow_wstr (&wchar_buf, LCST ("\""));
 526               in_quotes = 1;
 527             }
 528           need_escape = 0;
 529           print_wchar (gdb_WEOF, buf, buflen, width, &wchar_buf,
 530                        '"', &need_escape);
 531           break;
 532
 533         case wchar_iterate_incomplete:
 534           if (in_quotes)
 535             {
 536               if (options->inspect_it)
 537                 obstack_grow_wstr (&wchar_buf, LCST ("\\\","));
 538               else
 539                 obstack_grow_wstr (&wchar_buf, LCST ("\","));
 540               in_quotes = 0;
 541             }
 542           obstack_grow_wstr (&wchar_buf, LCST (" <incomplete sequence "));
 543           print_wchar (gdb_WEOF, buf, buflen, width, &wchar_buf,
 544                        0, &need_escape);
 545           obstack_grow_wstr (&wchar_buf, LCST (">"));
 546           finished = 1;
 547           break;
 548         }
 549     }
 550
 551   /* Terminate the quotes if necessary.  */
 552   if (in_quotes)
 553     {
 554       if (options->inspect_it)
 555         obstack_grow_wstr (&wchar_buf, LCST ("\\\""));
 556       else
 557         obstack_grow_wstr (&wchar_buf, LCST ("\""));
 558     }
 559
 560   if (force_ellipses || !finished)
 561     obstack_grow_wstr (&wchar_buf, LCST ("..."));
 562
 563   /* OUTPUT is where we collect `char's for printing.  */
 564   obstack_init (&output);
 565   make_cleanup_obstack_free (&output);
 566
 567   convert_between_encodings (INTERMEDIATE_ENCODING, host_charset (),
 568                              obstack_base (&wchar_buf),
 569                              obstack_object_size (&wchar_buf),
 570                              1, &output, translit_char);
 571   obstack_1grow (&output, '\0');
 572
 573   fputs_filtered (obstack_base (&output), stream);
 574
 575   do_cleanups (cleanup);
 576 }
 577
 578 /* Obtain a C string from the inferior storing it in a newly allocated
 579    buffer in BUFFER, which should be freed by the caller.  The string is
 580    read until a null character is found. If VALUE is an array with known
 581    length, the function will not read past the end of the array.  LENGTH
 582    will contain the size of the string in bytes (not counting the null
 583    character).
 584
 585    Assumes strings are terminated by a null character.  The size of a character
 586    is determined by the length of the target type of the pointer or array.
 587    This means that a null byte present in a multi-byte character will not
 588    terminate the string unless the whole character is null.
 589
 590    CHARSET is always set to the target charset.  */
 591
 592 void
 593 c_get_string (struct value *value, gdb_byte **buffer, int *length,
 594               const char **charset)
 595 {
 596   int err, width;
 597   unsigned int fetchlimit;
 598   struct type *type = check_typedef (value_type (value));
 599   struct type *element_type = TYPE_TARGET_TYPE (type);
 600
 601   if (element_type == NULL)
 602     goto error;
 603
 604   if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
 605     {
 606       /* If we know the size of the array, we can use it as a limit on the
 607          number of characters to be fetched.  */
 608       if (TYPE_NFIELDS (type) == 1
 609           && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_RANGE)
 610         {
 611           LONGEST low_bound, high_bound;
 612
 613           get_discrete_bounds (TYPE_FIELD_TYPE (type, 0),
 614                                &low_bound, &high_bound);
 615           fetchlimit = high_bound - low_bound + 1;
 616         }
 617       else
 618         fetchlimit = UINT_MAX;
 619     }
 620   else if (TYPE_CODE (type) == TYPE_CODE_PTR)
 621     fetchlimit = UINT_MAX;
 622   else
 623     /* We work only with arrays and pointers.  */
 624     goto error;
 625
 626   element_type = check_typedef (element_type);
 627   if (TYPE_CODE (element_type) != TYPE_CODE_INT
 628       && TYPE_CODE (element_type) != TYPE_CODE_CHAR)
 629     /* If the elements are not integers or characters, we don't consider it
 630        a string.  */
 631     goto error;
 632
 633   width = TYPE_LENGTH (element_type);
 634
 635   /* If the string lives in GDB's memory intead of the inferior's, then we
 636      just need to copy it to BUFFER.  Also, since such strings are arrays
 637      with known size, FETCHLIMIT will hold the size of the array.  */
 638   if ((VALUE_LVAL (value) == not_lval
 639        || VALUE_LVAL (value) == lval_internalvar)
 640       && fetchlimit != UINT_MAX)
 641     {
 642       int i;
 643       const gdb_byte *contents = value_contents (value);
 644
 645       /* Look for a null character.  */
 646       for (i = 0; i < fetchlimit; i++)
 647         if (extract_unsigned_integer (contents + i * width, width) == 0)
 648           break;
 649
 650       /* I is now either the number of non-null characters, or FETCHLIMIT.  */
 651       *length = i * width;
 652       *buffer = xmalloc (*length);
 653       memcpy (*buffer, contents, *length);
 654       err = 0;
 655     }
 656   else
 657     {
 658       err = read_string (value_as_address (value), -1, width, fetchlimit,
 659                          buffer, length);
 660       if (err)
 661         {
 662           xfree (*buffer);
 663           error (_("Error reading string from inferior: %s"),
 664                  safe_strerror (err));
 665         }
 666     }
 667
 668   /* If the last character is null, subtract it from LENGTH.  */
 669   if (*length > 0
 670       && extract_unsigned_integer (*buffer + *length - width, width) == 0)
 671     *length -= width;
 672
 673   *charset = target_charset ();
 674
 675   return;
 676
 677  error:
 678   {
 679     char *type_str;
 680
 681     type_str = type_to_string (type);
 682     if (type_str)
 683       {
 684         make_cleanup (xfree, type_str);
 685         error (_("Trying to read string with inappropriate type `%s'."),
 686                type_str);
 687       }
 688     else
 689       error (_("Trying to read string with inappropriate type."));
 690   }
 691 }
 692
 693 \f
 694 /* Evaluating C and C++ expressions.  */
 695
 696 /* Convert a UCN.  The digits of the UCN start at P and extend no
 697    farther than LIMIT.  DEST_CHARSET is the name of the character set
 698    into which the UCN should be converted.  The results are written to
 699    OUTPUT.  LENGTH is the maximum length of the UCN, either 4 or 8.
 700    Returns a pointer to just after the final digit of the UCN.  */
 701
 702 static char *
 703 convert_ucn (char *p, char *limit, const char *dest_charset,
 704              struct obstack *output, int length)
 705 {
 706   unsigned long result = 0;
 707   gdb_byte data[4];
 708   int i;
 709
 710   for (i = 0; i < length && p < limit && isxdigit (*p); ++i, ++p)
 711     result = (result << 4) + host_hex_value (*p);
 712
 713   for (i = 3; i >= 0; --i)
 714     {
 715       data[i] = result & 0xff;
 716       result >>= 8;
 717     }
 718
 719   convert_between_encodings ("UCS-4BE", dest_charset, data, 4, 4, output,
 720                              translit_none);
 721
 722   return p;
 723 }
 724
 725 /* Emit a character, VALUE, which was specified numerically, to
 726    OUTPUT.  TYPE is the target character type.  */
 727
 728 static void
 729 emit_numeric_character (struct type *type, unsigned long value,
 730                         struct obstack *output)
 731 {
 732   gdb_byte *buffer;
 733
 734   buffer = alloca (TYPE_LENGTH (type));
 735   pack_long (buffer, type, value);
 736   obstack_grow (output, buffer, TYPE_LENGTH (type));
 737 }
 738
 739 /* Convert an octal escape sequence.  TYPE is the target character
 740    type.  The digits of the escape sequence begin at P and extend no
 741    farther than LIMIT.  The result is written to OUTPUT.  Returns a
 742    pointer to just after the final digit of the escape sequence.  */
 743
 744 static char *
 745 convert_octal (struct type *type, char *p, char *limit, struct obstack *output)
 746 {
 747   unsigned long value = 0;
 748
 749   while (p < limit && isdigit (*p) && *p != '8' && *p != '9')
 750     {
 751       value = 8 * value + host_hex_value (*p);
 752       ++p;
 753     }
 754
 755   emit_numeric_character (type, value, output);
 756
 757   return p;
 758 }
 759
 760 /* Convert a hex escape sequence.  TYPE is the target character type.
 761    The digits of the escape sequence begin at P and extend no farther
 762    than LIMIT.  The result is written to OUTPUT.  Returns a pointer to
 763    just after the final digit of the escape sequence.  */
 764
 765 static char *
 766 convert_hex (struct type *type, char *p, char *limit, struct obstack *output)
 767 {
 768   unsigned long value = 0;
 769
 770   while (p < limit && isxdigit (*p))
 771     {
 772       value = 16 * value + host_hex_value (*p);
 773       ++p;
 774     }
 775
 776   emit_numeric_character (type, value, output);
 777
 778   return p;
 779 }
 780
 781 #define ADVANCE                                 \
 782   do {                                          \
 783     ++p;                                        \
 784     if (p == limit)                             \
 785       error (_("Malformed escape sequence"));   \
 786   } while (0)
 787
 788 /* Convert an escape sequence to a target format.  TYPE is the target
 789    character type to use, and DEST_CHARSET is the name of the target
 790    character set.  The backslash of the escape sequence is at *P, and
 791    the escape sequence will not extend past LIMIT.  The results are
 792    written to OUTPUT.  Returns a pointer to just past the final
 793    character of the escape sequence.  */
 794
 795 static char *
 796 convert_escape (struct type *type, const char *dest_charset,
 797                 char *p, char *limit, struct obstack *output)
 798 {
 799   /* Skip the backslash.  */
 800   ADVANCE;
 801
 802   switch (*p)
 803     {
 804     case '\\':
 805       obstack_1grow (output, '\\');
 806       ++p;
 807       break;
 808
 809     case 'x':
 810       ADVANCE;
 811       if (!isxdigit (*p))
 812         error (_("\\x used with no following hex digits."));
 813       p = convert_hex (type, p, limit, output);
 814       break;
 815
 816     case '0':
 817     case '1':
 818     case '2':
 819     case '3':
 820     case '4':
 821     case '5':
 822     case '6':
 823     case '7':
 824       p = convert_octal (type, p, limit, output);
 825       break;
 826
 827     case 'u':
 828     case 'U':
 829       {
 830         int length = *p == 'u' ? 4 : 8;
 831         ADVANCE;
 832         if (!isxdigit (*p))
 833           error (_("\\u used with no following hex digits"));
 834         p = convert_ucn (p, limit, dest_charset, output, length);
 835       }
 836     }
 837
 838   return p;
 839 }
 840
 841 /* Given a single string from a (C-specific) OP_STRING list, convert
 842    it to a target string, handling escape sequences specially.  The
 843    output is written to OUTPUT.  DATA is the input string, which has
 844    length LEN.  DEST_CHARSET is the name of the target character set,
 845    and TYPE is the type of target character to use.  */
 846
 847 static void
 848 parse_one_string (struct obstack *output, char *data, int len,
 849                   const char *dest_charset, struct type *type)
 850 {
 851   char *limit;
 852
 853   limit = data + len;
 854
 855   while (data < limit)
 856     {
 857       char *p = data;
 858       /* Look for next escape, or the end of the input.  */
 859       while (p < limit && *p != '\\')
 860         ++p;
 861       /* If we saw a run of characters, convert them all.  */
 862       if (p > data)
 863         convert_between_encodings (host_charset (), dest_charset,
 864                                    data, p - data, 1, output, translit_none);
 865       /* If we saw an escape, convert it.  */
 866       if (p < limit)
 867         p = convert_escape (type, dest_charset, p, limit, output);
 868       data = p;
 869     }
 870 }
 871
 872 /* Expression evaluator for the C language family.  Most operations
 873    are delegated to evaluate_subexp_standard; see that function for a
 874    description of the arguments.  */
 875
 876 static struct value *
 877 evaluate_subexp_c (struct type *expect_type, struct expression *exp,
 878                    int *pos, enum noside noside)
 879 {
 880   enum exp_opcode op = exp->elts[*pos].opcode;
 881
 882   switch (op)
 883     {
 884     case OP_STRING:
 885       {
 886         int oplen, limit;
 887         struct type *type;
 888         struct obstack output;
 889         struct cleanup *cleanup;
 890         struct value *result;
 891         enum c_string_type dest_type;
 892         const char *dest_charset;
 893
 894         obstack_init (&output);
 895         cleanup = make_cleanup_obstack_free (&output);
 896
 897         ++*pos;
 898         oplen = longest_to_int (exp->elts[*pos].longconst);
 899
 900         ++*pos;
 901         limit = *pos + BYTES_TO_EXP_ELEM (oplen + 1);
 902         dest_type
 903           = (enum c_string_type) longest_to_int (exp->elts[*pos].longconst);
 904         switch (dest_type & ~C_CHAR)
 905           {
 906           case C_STRING:
 907             type = language_string_char_type (current_language,
 908                                               current_gdbarch);
 909             break;
 910           case C_WIDE_STRING:
 911             type = lookup_typename ("wchar_t", NULL, 0);
 912             break;
 913           case C_STRING_16:
 914             type = lookup_typename ("char16_t", NULL, 0);
 915             break;
 916           case C_STRING_32:
 917             type = lookup_typename ("char32_t", NULL, 0);
 918             break;
 919           default:
 920             internal_error (__FILE__, __LINE__, "unhandled c_string_type");
 921           }
 922
 923         /* Ensure TYPE_LENGTH is valid for TYPE.  */
 924         check_typedef (type);
 925
 926         dest_charset = charset_for_string_type (dest_type);
 927
 928         ++*pos;
 929         while (*pos < limit)
 930           {
 931             int len;
 932
 933             len = longest_to_int (exp->elts[*pos].longconst);
 934
 935             ++*pos;
 936             if (noside != EVAL_SKIP)
 937               parse_one_string (&output, &exp->elts[*pos].string, len,
 938                                 dest_charset, type);
 939             *pos += BYTES_TO_EXP_ELEM (len);
 940           }
 941
 942         /* Skip the trailing length and opcode.  */
 943         *pos += 2;
 944
 945         if (noside == EVAL_SKIP)
 946           {
 947             /* Return a dummy value of the appropriate type.  */
 948             if ((dest_type & C_CHAR) != 0)
 949               result = allocate_value (type);
 950             else
 951               result = value_typed_string ("", 0, type);
 952             do_cleanups (cleanup);
 953             return result;
 954           }
 955
 956         if ((dest_type & C_CHAR) != 0)
 957           {
 958             LONGEST value;
 959
 960             if (obstack_object_size (&output) != TYPE_LENGTH (type))
 961               error (_("Could not convert character constant to target character set"));
 962             value = unpack_long (type, obstack_base (&output));
 963             result = value_from_longest (type, value);
 964           }
 965         else
 966           {
 967             int i;
 968             /* Write the terminating character.  */
 969             for (i = 0; i < TYPE_LENGTH (type); ++i)
 970               obstack_1grow (&output, 0);
 971             result = value_typed_string (obstack_base (&output),
 972                                          obstack_object_size (&output),
 973                                          type);
 974           }
 975         do_cleanups (cleanup);
 976         return result;
 977       }
 978       break;
 979
 980     default:
 981       break;
 982     }
 983   return evaluate_subexp_standard (expect_type, exp, pos, noside);
 984 }
 985
 986
 987 \f
 988 /* Table mapping opcodes into strings for printing operators
 989    and precedences of the operators.  */
 990
 991 const struct op_print c_op_print_tab[] =
 992 {
 993   {",", BINOP_COMMA, PREC_COMMA, 0},
 994   {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
 995   {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
 996   {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
 997   {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
 998   {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
 999   {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
1000   {"==", BINOP_EQUAL, PREC_EQUAL, 0},
1001   {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
1002   {"<=", BINOP_LEQ, PREC_ORDER, 0},
1003   {">=", BINOP_GEQ, PREC_ORDER, 0},
1004   {">", BINOP_GTR, PREC_ORDER, 0},
1005   {"<", BINOP_LESS, PREC_ORDER, 0},
1006   {">>", BINOP_RSH, PREC_SHIFT, 0},
1007   {"<<", BINOP_LSH, PREC_SHIFT, 0},
1008   {"+", BINOP_ADD, PREC_ADD, 0},
1009   {"-", BINOP_SUB, PREC_ADD, 0},
1010   {"*", BINOP_MUL, PREC_MUL, 0},
1011   {"/", BINOP_DIV, PREC_MUL, 0},
1012   {"%", BINOP_REM, PREC_MUL, 0},
1013   {"@", BINOP_REPEAT, PREC_REPEAT, 0},
1014   {"-", UNOP_NEG, PREC_PREFIX, 0},
1015   {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
1016   {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
1017   {"*", UNOP_IND, PREC_PREFIX, 0},
1018   {"&", UNOP_ADDR, PREC_PREFIX, 0},
1019   {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
1020   {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
1021   {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
1022   {NULL, 0, 0, 0}
1023 };
1024 \f
1025 enum c_primitive_types {
1026   c_primitive_type_int,
1027   c_primitive_type_long,
1028   c_primitive_type_short,
1029   c_primitive_type_char,
1030   c_primitive_type_float,
1031   c_primitive_type_double,
1032   c_primitive_type_void,
1033   c_primitive_type_long_long,
1034   c_primitive_type_signed_char,
1035   c_primitive_type_unsigned_char,
1036   c_primitive_type_unsigned_short,
1037   c_primitive_type_unsigned_int,
1038   c_primitive_type_unsigned_long,
1039   c_primitive_type_unsigned_long_long,
1040   c_primitive_type_long_double,
1041   c_primitive_type_complex,
1042   c_primitive_type_double_complex,
1043   c_primitive_type_decfloat,
1044   c_primitive_type_decdouble,
1045   c_primitive_type_declong,
1046   nr_c_primitive_types
1047 };
1048
1049 void
1050 c_language_arch_info (struct gdbarch *gdbarch,
1051                       struct language_arch_info *lai)
1052 {
1053   const struct builtin_type *builtin = builtin_type (gdbarch);
1054   lai->string_char_type = builtin->builtin_char;
1055   lai->primitive_type_vector
1056     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1,
1057                               struct type *);
1058   lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int;
1059   lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long;
1060   lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short;
1061   lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char;
1062   lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float;
1063   lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double;
1064   lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void;
1065   lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long;
1066   lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char;
1067   lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char;
1068   lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short;
1069   lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int;
1070   lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long;
1071   lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long;
1072   lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double;
1073   lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex;
1074   lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex;
1075   lai->primitive_type_vector [c_primitive_type_decfloat] = builtin->builtin_decfloat;
1076   lai->primitive_type_vector [c_primitive_type_decdouble] = builtin->builtin_decdouble;
1077   lai->primitive_type_vector [c_primitive_type_declong] = builtin->builtin_declong;
1078
1079   lai->bool_type_default = builtin->builtin_int;
1080 }
1081
1082 static const struct exp_descriptor exp_descriptor_c =
1083 {
1084   print_subexp_standard,
1085   operator_length_standard,
1086   op_name_standard,
1087   dump_subexp_body_standard,
1088   evaluate_subexp_c
1089 };
1090
1091 const struct language_defn c_language_defn =
1092 {
1093   "c",                          /* Language name */
1094   language_c,
1095   range_check_off,
1096   type_check_off,
1097   case_sensitive_on,
1098   array_row_major,
1099   macro_expansion_c,
1100   &exp_descriptor_c,
1101   c_parse,
1102   c_error,
1103   null_post_parser,
1104   c_printchar,                  /* Print a character constant */
1105   c_printstr,                   /* Function to print string constant */
1106   c_emit_char,                  /* Print a single char */
1107   c_print_type,                 /* Print a type using appropriate syntax */
1108   c_print_typedef,              /* Print a typedef using appropriate syntax */
1109   c_val_print,                  /* Print a value using appropriate syntax */
1110   c_value_print,                /* Print a top-level value */
1111   NULL,                         /* Language specific skip_trampoline */
1112   NULL,                         /* name_of_this */
1113   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1114   basic_lookup_transparent_type,/* lookup_transparent_type */
1115   NULL,                         /* Language specific symbol demangler */
1116   NULL,                         /* Language specific class_name_from_physname */
1117   c_op_print_tab,               /* expression operators for printing */
1118   1,                            /* c-style arrays */
1119   0,                            /* String lower bound */
1120   default_word_break_characters,
1121   default_make_symbol_completion_list,
1122   c_language_arch_info,
1123   default_print_array_index,
1124   default_pass_by_reference,
1125   c_get_string,
1126   LANG_MAGIC
1127 };
1128
1129 enum cplus_primitive_types {
1130   cplus_primitive_type_int,
1131   cplus_primitive_type_long,
1132   cplus_primitive_type_short,
1133   cplus_primitive_type_char,
1134   cplus_primitive_type_float,
1135   cplus_primitive_type_double,
1136   cplus_primitive_type_void,
1137   cplus_primitive_type_long_long,
1138   cplus_primitive_type_signed_char,
1139   cplus_primitive_type_unsigned_char,
1140   cplus_primitive_type_unsigned_short,
1141   cplus_primitive_type_unsigned_int,
1142   cplus_primitive_type_unsigned_long,
1143   cplus_primitive_type_unsigned_long_long,
1144   cplus_primitive_type_long_double,
1145   cplus_primitive_type_complex,
1146   cplus_primitive_type_double_complex,
1147   cplus_primitive_type_bool,
1148   cplus_primitive_type_decfloat,
1149   cplus_primitive_type_decdouble,
1150   cplus_primitive_type_declong,
1151   nr_cplus_primitive_types
1152 };
1153
1154 static void
1155 cplus_language_arch_info (struct gdbarch *gdbarch,
1156                           struct language_arch_info *lai)
1157 {
1158   const struct builtin_type *builtin = builtin_type (gdbarch);
1159   lai->string_char_type = builtin->builtin_char;
1160   lai->primitive_type_vector
1161     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1,
1162                               struct type *);
1163   lai->primitive_type_vector [cplus_primitive_type_int]
1164     = builtin->builtin_int;
1165   lai->primitive_type_vector [cplus_primitive_type_long]
1166     = builtin->builtin_long;
1167   lai->primitive_type_vector [cplus_primitive_type_short]
1168     = builtin->builtin_short;
1169   lai->primitive_type_vector [cplus_primitive_type_char]
1170     = builtin->builtin_char;
1171   lai->primitive_type_vector [cplus_primitive_type_float]
1172     = builtin->builtin_float;
1173   lai->primitive_type_vector [cplus_primitive_type_double]
1174     = builtin->builtin_double;
1175   lai->primitive_type_vector [cplus_primitive_type_void]
1176     = builtin->builtin_void;
1177   lai->primitive_type_vector [cplus_primitive_type_long_long]
1178     = builtin->builtin_long_long;
1179   lai->primitive_type_vector [cplus_primitive_type_signed_char]
1180     = builtin->builtin_signed_char;
1181   lai->primitive_type_vector [cplus_primitive_type_unsigned_char]
1182     = builtin->builtin_unsigned_char;
1183   lai->primitive_type_vector [cplus_primitive_type_unsigned_short]
1184     = builtin->builtin_unsigned_short;
1185   lai->primitive_type_vector [cplus_primitive_type_unsigned_int]
1186     = builtin->builtin_unsigned_int;
1187   lai->primitive_type_vector [cplus_primitive_type_unsigned_long]
1188     = builtin->builtin_unsigned_long;
1189   lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long]
1190     = builtin->builtin_unsigned_long_long;
1191   lai->primitive_type_vector [cplus_primitive_type_long_double]
1192     = builtin->builtin_long_double;
1193   lai->primitive_type_vector [cplus_primitive_type_complex]
1194     = builtin->builtin_complex;
1195   lai->primitive_type_vector [cplus_primitive_type_double_complex]
1196     = builtin->builtin_double_complex;
1197   lai->primitive_type_vector [cplus_primitive_type_bool]
1198     = builtin->builtin_bool;
1199   lai->primitive_type_vector [cplus_primitive_type_decfloat]
1200     = builtin->builtin_decfloat;
1201   lai->primitive_type_vector [cplus_primitive_type_decdouble]
1202     = builtin->builtin_decdouble;
1203   lai->primitive_type_vector [cplus_primitive_type_declong]
1204     = builtin->builtin_declong;
1205
1206   lai->bool_type_symbol = "bool";
1207   lai->bool_type_default = builtin->builtin_bool;
1208 }
1209
1210 const struct language_defn cplus_language_defn =
1211 {
1212   "c++",                        /* Language name */
1213   language_cplus,
1214   range_check_off,
1215   type_check_off,
1216   case_sensitive_on,
1217   array_row_major,
1218   macro_expansion_c,
1219   &exp_descriptor_c,
1220   c_parse,
1221   c_error,
1222   null_post_parser,
1223   c_printchar,                  /* Print a character constant */
1224   c_printstr,                   /* Function to print string constant */
1225   c_emit_char,                  /* Print a single char */
1226   c_print_type,                 /* Print a type using appropriate syntax */
1227   c_print_typedef,              /* Print a typedef using appropriate syntax */
1228   c_val_print,                  /* Print a value using appropriate syntax */
1229   c_value_print,                /* Print a top-level value */
1230   cplus_skip_trampoline,        /* Language specific skip_trampoline */
1231   "this",                       /* name_of_this */
1232   cp_lookup_symbol_nonlocal,    /* lookup_symbol_nonlocal */
1233   cp_lookup_transparent_type,   /* lookup_transparent_type */
1234   cplus_demangle,               /* Language specific symbol demangler */
1235   cp_class_name_from_physname,  /* Language specific class_name_from_physname */
1236   c_op_print_tab,               /* expression operators for printing */
1237   1,                            /* c-style arrays */
1238   0,                            /* String lower bound */
1239   default_word_break_characters,
1240   default_make_symbol_completion_list,
1241   cplus_language_arch_info,
1242   default_print_array_index,
1243   cp_pass_by_reference,
1244   c_get_string,
1245   LANG_MAGIC
1246 };
1247
1248 const struct language_defn asm_language_defn =
1249 {
1250   "asm",                        /* Language name */
1251   language_asm,
1252   range_check_off,
1253   type_check_off,
1254   case_sensitive_on,
1255   array_row_major,
1256   macro_expansion_c,
1257   &exp_descriptor_c,
1258   c_parse,
1259   c_error,
1260   null_post_parser,
1261   c_printchar,                  /* Print a character constant */
1262   c_printstr,                   /* Function to print string constant */
1263   c_emit_char,                  /* Print a single char */
1264   c_print_type,                 /* Print a type using appropriate syntax */
1265   c_print_typedef,              /* Print a typedef using appropriate syntax */
1266   c_val_print,                  /* Print a value using appropriate syntax */
1267   c_value_print,                /* Print a top-level value */
1268   NULL,                         /* Language specific skip_trampoline */
1269   NULL,                         /* name_of_this */
1270   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1271   basic_lookup_transparent_type,/* lookup_transparent_type */
1272   NULL,                         /* Language specific symbol demangler */
1273   NULL,                         /* Language specific class_name_from_physname */
1274   c_op_print_tab,               /* expression operators for printing */
1275   1,                            /* c-style arrays */
1276   0,                            /* String lower bound */
1277   default_word_break_characters,
1278   default_make_symbol_completion_list,
1279   c_language_arch_info, /* FIXME: la_language_arch_info.  */
1280   default_print_array_index,
1281   default_pass_by_reference,
1282   c_get_string,
1283   LANG_MAGIC
1284 };
1285
1286 /* The following language_defn does not represent a real language.
1287    It just provides a minimal support a-la-C that should allow users
1288    to do some simple operations when debugging applications that use
1289    a language currently not supported by GDB.  */
1290
1291 const struct language_defn minimal_language_defn =
1292 {
1293   "minimal",                    /* Language name */
1294   language_minimal,
1295   range_check_off,
1296   type_check_off,
1297   case_sensitive_on,
1298   array_row_major,
1299   macro_expansion_c,
1300   &exp_descriptor_c,
1301   c_parse,
1302   c_error,
1303   null_post_parser,
1304   c_printchar,                  /* Print a character constant */
1305   c_printstr,                   /* Function to print string constant */
1306   c_emit_char,                  /* Print a single char */
1307   c_print_type,                 /* Print a type using appropriate syntax */
1308   c_print_typedef,              /* Print a typedef using appropriate syntax */
1309   c_val_print,                  /* Print a value using appropriate syntax */
1310   c_value_print,                /* Print a top-level value */
1311   NULL,                         /* Language specific skip_trampoline */
1312   NULL,                         /* name_of_this */
1313   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1314   basic_lookup_transparent_type,/* lookup_transparent_type */
1315   NULL,                         /* Language specific symbol demangler */
1316   NULL,                         /* Language specific class_name_from_physname */
1317   c_op_print_tab,               /* expression operators for printing */
1318   1,                            /* c-style arrays */
1319   0,                            /* String lower bound */
1320   default_word_break_characters,
1321   default_make_symbol_completion_list,
1322   c_language_arch_info,
1323   default_print_array_index,
1324   default_pass_by_reference,
1325   c_get_string,
1326   LANG_MAGIC
1327 };
1328
1329 void
1330 _initialize_c_language (void)
1331 {
1332   add_language (&c_language_defn);
1333   add_language (&cplus_language_defn);
1334   add_language (&asm_language_defn);
1335   add_language (&minimal_language_defn);
1336 }