gdb/c-lang.c

   1 /* C language support routines for GDB, the GNU debugger.
   2
   3    Copyright (C) 1992-2014 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 3 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, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "symtab.h"
  22 #include "gdbtypes.h"
  23 #include "expression.h"
  24 #include "parser-defs.h"
  25 #include "language.h"
  26 #include "varobj.h"
  27 #include "c-lang.h"
  28 #include "valprint.h"
  29 #include "macroscope.h"
  30 #include "charset.h"
  31 #include <string.h>
  32 #include "demangle.h"
  33 #include "cp-abi.h"
  34 #include "cp-support.h"
  35 #include "gdb_obstack.h"
  36 #include <ctype.h>
  37 #include "exceptions.h"
  38 #include "gdbcore.h"
  39
  40 extern void _initialize_c_language (void);
  41
  42 /* Given a C string type, STR_TYPE, return the corresponding target
  43    character set name.  */
  44
  45 static const char *
  46 charset_for_string_type (enum c_string_type str_type,
  47                          struct gdbarch *gdbarch)
  48 {
  49   switch (str_type & ~C_CHAR)
  50     {
  51     case C_STRING:
  52       return target_charset (gdbarch);
  53     case C_WIDE_STRING:
  54       return target_wide_charset (gdbarch);
  55     case C_STRING_16:
  56       /* FIXME: UTF-16 is not always correct.  */
  57       if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
  58         return "UTF-16BE";
  59       else
  60         return "UTF-16LE";
  61     case C_STRING_32:
  62       /* FIXME: UTF-32 is not always correct.  */
  63       if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
  64         return "UTF-32BE";
  65       else
  66         return "UTF-32LE";
  67     }
  68   internal_error (__FILE__, __LINE__, _("unhandled c_string_type"));
  69 }
  70
  71 /* Classify ELTTYPE according to what kind of character it is.  Return
  72    the enum constant representing the character type.  Also set
  73    *ENCODING to the name of the character set to use when converting
  74    characters of this type in target BYTE_ORDER to the host character
  75    set.  */
  76
  77 static enum c_string_type
  78 classify_type (struct type *elttype, struct gdbarch *gdbarch,
  79                const char **encoding)
  80 {
  81   enum c_string_type result;
  82
  83   /* We loop because ELTTYPE may be a typedef, and we want to
  84      successively peel each typedef until we reach a type we
  85      understand.  We don't use CHECK_TYPEDEF because that will strip
  86      all typedefs at once -- but in C, wchar_t is itself a typedef, so
  87      that would do the wrong thing.  */
  88   while (elttype)
  89     {
  90       const char *name = TYPE_NAME (elttype);
  91
  92       if (TYPE_CODE (elttype) == TYPE_CODE_CHAR || !name)
  93         {
  94           result = C_CHAR;
  95           goto done;
  96         }
  97
  98       if (!strcmp (name, "wchar_t"))
  99         {
 100           result = C_WIDE_CHAR;
 101           goto done;
 102         }
 103
 104       if (!strcmp (name, "char16_t"))
 105         {
 106           result = C_CHAR_16;
 107           goto done;
 108         }
 109
 110       if (!strcmp (name, "char32_t"))
 111         {
 112           result = C_CHAR_32;
 113           goto done;
 114         }
 115
 116       if (TYPE_CODE (elttype) != TYPE_CODE_TYPEDEF)
 117         break;
 118
 119       /* Call for side effects.  */
 120       check_typedef (elttype);
 121
 122       if (TYPE_TARGET_TYPE (elttype))
 123         elttype = TYPE_TARGET_TYPE (elttype);
 124       else
 125         {
 126           /* Perhaps check_typedef did not update the target type.  In
 127              this case, force the lookup again and hope it works out.
 128              It never will for C, but it might for C++.  */
 129           CHECK_TYPEDEF (elttype);
 130         }
 131     }
 132
 133   /* Punt.  */
 134   result = C_CHAR;
 135
 136  done:
 137   if (encoding)
 138     *encoding = charset_for_string_type (result, gdbarch);
 139
 140   return result;
 141 }
 142
 143 /* Print the character C on STREAM as part of the contents of a
 144    literal string whose delimiter is QUOTER.  Note that that format
 145    for printing characters and strings is language specific.  */
 146
 147 void
 148 c_emit_char (int c, struct type *type,
 149              struct ui_file *stream, int quoter)
 150 {
 151   const char *encoding;
 152
 153   classify_type (type, get_type_arch (type), &encoding);
 154   generic_emit_char (c, type, stream, quoter, encoding);
 155 }
 156
 157 void
 158 c_printchar (int c, struct type *type, struct ui_file *stream)
 159 {
 160   enum c_string_type str_type;
 161
 162   str_type = classify_type (type, get_type_arch (type), NULL);
 163   switch (str_type)
 164     {
 165     case C_CHAR:
 166       break;
 167     case C_WIDE_CHAR:
 168       fputc_filtered ('L', stream);
 169       break;
 170     case C_CHAR_16:
 171       fputc_filtered ('u', stream);
 172       break;
 173     case C_CHAR_32:
 174       fputc_filtered ('U', stream);
 175       break;
 176     }
 177
 178   fputc_filtered ('\'', stream);
 179   LA_EMIT_CHAR (c, type, stream, '\'');
 180   fputc_filtered ('\'', stream);
 181 }
 182
 183 /* Print the character string STRING, printing at most LENGTH
 184    characters.  LENGTH is -1 if the string is nul terminated.  Each
 185    character is WIDTH bytes long.  Printing stops early if the number
 186    hits print_max; repeat counts are printed as appropriate.  Print
 187    ellipses at the end if we had to stop before printing LENGTH
 188    characters, or if FORCE_ELLIPSES.  */
 189
 190 void
 191 c_printstr (struct ui_file *stream, struct type *type,
 192             const gdb_byte *string, unsigned int length,
 193             const char *user_encoding, int force_ellipses,
 194             const struct value_print_options *options)
 195 {
 196   enum c_string_type str_type;
 197   const char *type_encoding;
 198   const char *encoding;
 199
 200   str_type = (classify_type (type, get_type_arch (type), &type_encoding)
 201               & ~C_CHAR);
 202   switch (str_type)
 203     {
 204     case C_STRING:
 205       break;
 206     case C_WIDE_STRING:
 207       fputs_filtered ("L", stream);
 208       break;
 209     case C_STRING_16:
 210       fputs_filtered ("u", stream);
 211       break;
 212     case C_STRING_32:
 213       fputs_filtered ("U", stream);
 214       break;
 215     }
 216
 217   encoding = (user_encoding && *user_encoding) ? user_encoding : type_encoding;
 218
 219   generic_printstr (stream, type, string, length, encoding, force_ellipses,
 220                     '"', 1, options);
 221 }
 222
 223 /* Obtain a C string from the inferior storing it in a newly allocated
 224    buffer in BUFFER, which should be freed by the caller.  If the in-
 225    and out-parameter *LENGTH is specified at -1, the string is read
 226    until a null character of the appropriate width is found, otherwise
 227    the string is read to the length of characters specified.  The size
 228    of a character is determined by the length of the target type of
 229    the pointer or array.
 230
 231    If VALUE is an array with a known length, and *LENGTH is -1,
 232    the function will not read past the end of the array.  However, any
 233    declared size of the array is ignored if *LENGTH > 0.
 234
 235    On completion, *LENGTH will be set to the size of the string read in
 236    characters.  (If a length of -1 is specified, the length returned
 237    will not include the null character).  CHARSET is always set to the
 238    target charset.  */
 239
 240 void
 241 c_get_string (struct value *value, gdb_byte **buffer,
 242               int *length, struct type **char_type,
 243               const char **charset)
 244 {
 245   int err, width;
 246   unsigned int fetchlimit;
 247   struct type *type = check_typedef (value_type (value));
 248   struct type *element_type = TYPE_TARGET_TYPE (type);
 249   int req_length = *length;
 250   enum bfd_endian byte_order
 251     = gdbarch_byte_order (get_type_arch (type));
 252
 253   if (element_type == NULL)
 254     goto error;
 255
 256   if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
 257     {
 258       /* If we know the size of the array, we can use it as a limit on
 259          the number of characters to be fetched.  */
 260       if (TYPE_NFIELDS (type) == 1
 261           && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_RANGE)
 262         {
 263           LONGEST low_bound, high_bound;
 264
 265           get_discrete_bounds (TYPE_FIELD_TYPE (type, 0),
 266                                &low_bound, &high_bound);
 267           fetchlimit = high_bound - low_bound + 1;
 268         }
 269       else
 270         fetchlimit = UINT_MAX;
 271     }
 272   else if (TYPE_CODE (type) == TYPE_CODE_PTR)
 273     fetchlimit = UINT_MAX;
 274   else
 275     /* We work only with arrays and pointers.  */
 276     goto error;
 277
 278   if (! c_textual_element_type (element_type, 0))
 279     goto error;
 280   classify_type (element_type, get_type_arch (element_type), charset);
 281   width = TYPE_LENGTH (element_type);
 282
 283   /* If the string lives in GDB's memory instead of the inferior's,
 284      then we just need to copy it to BUFFER.  Also, since such strings
 285      are arrays with known size, FETCHLIMIT will hold the size of the
 286      array.  */
 287   if ((VALUE_LVAL (value) == not_lval
 288        || VALUE_LVAL (value) == lval_internalvar)
 289       && fetchlimit != UINT_MAX)
 290     {
 291       int i;
 292       const gdb_byte *contents = value_contents (value);
 293
 294       /* If a length is specified, use that.  */
 295       if (*length >= 0)
 296         i  = *length;
 297       else
 298         /* Otherwise, look for a null character.  */
 299         for (i = 0; i < fetchlimit; i++)
 300           if (extract_unsigned_integer (contents + i * width,
 301                                         width, byte_order) == 0)
 302             break;
 303
 304       /* I is now either a user-defined length, the number of non-null
 305          characters, or FETCHLIMIT.  */
 306       *length = i * width;
 307       *buffer = xmalloc (*length);
 308       memcpy (*buffer, contents, *length);
 309       err = 0;
 310     }
 311   else
 312     {
 313       CORE_ADDR addr = value_as_address (value);
 314
 315       /* Prior to the fix for PR 16196 read_string would ignore fetchlimit
 316          if length > 0.  The old "broken" behaviour is the behaviour we want:
 317          The caller may want to fetch 100 bytes from a variable length array
 318          implemented using the common idiom of having an array of length 1 at
 319          the end of a struct.  In this case we want to ignore the declared
 320          size of the array.  However, it's counterintuitive to implement that
 321          behaviour in read_string: what does fetchlimit otherwise mean if
 322          length > 0.  Therefore we implement the behaviour we want here:
 323          If *length > 0, don't specify a fetchlimit.  This preserves the
 324          previous behaviour.  We could move this check above where we know
 325          whether the array is declared with a fixed size, but we only want
 326          to apply this behaviour when calling read_string.  PR 16286.  */
 327       if (*length > 0)
 328         fetchlimit = UINT_MAX;
 329
 330       err = read_string (addr, *length, width, fetchlimit,
 331                          byte_order, buffer, length);
 332       if (err)
 333         {
 334           xfree (*buffer);
 335           memory_error (err, addr);
 336         }
 337     }
 338
 339   /* If the LENGTH is specified at -1, we want to return the string
 340      length up to the terminating null character.  If an actual length
 341      was specified, we want to return the length of exactly what was
 342      read.  */
 343   if (req_length == -1)
 344     /* If the last character is null, subtract it from LENGTH.  */
 345     if (*length > 0
 346         && extract_unsigned_integer (*buffer + *length - width,
 347                                      width, byte_order) == 0)
 348       *length -= width;
 349
 350   /* The read_string function will return the number of bytes read.
 351      If length returned from read_string was > 0, return the number of
 352      characters read by dividing the number of bytes by width.  */
 353   if (*length != 0)
 354      *length = *length / width;
 355
 356   *char_type = element_type;
 357
 358   return;
 359
 360  error:
 361   {
 362     char *type_str;
 363
 364     type_str = type_to_string (type);
 365     if (type_str)
 366       {
 367         make_cleanup (xfree, type_str);
 368         error (_("Trying to read string with inappropriate type `%s'."),
 369                type_str);
 370       }
 371     else
 372       error (_("Trying to read string with inappropriate type."));
 373   }
 374 }
 375
 376 \f
 377 /* Evaluating C and C++ expressions.  */
 378
 379 /* Convert a UCN.  The digits of the UCN start at P and extend no
 380    farther than LIMIT.  DEST_CHARSET is the name of the character set
 381    into which the UCN should be converted.  The results are written to
 382    OUTPUT.  LENGTH is the maximum length of the UCN, either 4 or 8.
 383    Returns a pointer to just after the final digit of the UCN.  */
 384
 385 static char *
 386 convert_ucn (char *p, char *limit, const char *dest_charset,
 387              struct obstack *output, int length)
 388 {
 389   unsigned long result = 0;
 390   gdb_byte data[4];
 391   int i;
 392
 393   for (i = 0; i < length && p < limit && isxdigit (*p); ++i, ++p)
 394     result = (result << 4) + host_hex_value (*p);
 395
 396   for (i = 3; i >= 0; --i)
 397     {
 398       data[i] = result & 0xff;
 399       result >>= 8;
 400     }
 401
 402   convert_between_encodings ("UTF-32BE", dest_charset, data,
 403                              4, 4, output, translit_none);
 404
 405   return p;
 406 }
 407
 408 /* Emit a character, VALUE, which was specified numerically, to
 409    OUTPUT.  TYPE is the target character type.  */
 410
 411 static void
 412 emit_numeric_character (struct type *type, unsigned long value,
 413                         struct obstack *output)
 414 {
 415   gdb_byte *buffer;
 416
 417   buffer = alloca (TYPE_LENGTH (type));
 418   pack_long (buffer, type, value);
 419   obstack_grow (output, buffer, TYPE_LENGTH (type));
 420 }
 421
 422 /* Convert an octal escape sequence.  TYPE is the target character
 423    type.  The digits of the escape sequence begin at P and extend no
 424    farther than LIMIT.  The result is written to OUTPUT.  Returns a
 425    pointer to just after the final digit of the escape sequence.  */
 426
 427 static char *
 428 convert_octal (struct type *type, char *p,
 429                char *limit, struct obstack *output)
 430 {
 431   int i;
 432   unsigned long value = 0;
 433
 434   for (i = 0;
 435        i < 3 && p < limit && isdigit (*p) && *p != '8' && *p != '9';
 436        ++i)
 437     {
 438       value = 8 * value + host_hex_value (*p);
 439       ++p;
 440     }
 441
 442   emit_numeric_character (type, value, output);
 443
 444   return p;
 445 }
 446
 447 /* Convert a hex escape sequence.  TYPE is the target character type.
 448    The digits of the escape sequence begin at P and extend no farther
 449    than LIMIT.  The result is written to OUTPUT.  Returns a pointer to
 450    just after the final digit of the escape sequence.  */
 451
 452 static char *
 453 convert_hex (struct type *type, char *p,
 454              char *limit, struct obstack *output)
 455 {
 456   unsigned long value = 0;
 457
 458   while (p < limit && isxdigit (*p))
 459     {
 460       value = 16 * value + host_hex_value (*p);
 461       ++p;
 462     }
 463
 464   emit_numeric_character (type, value, output);
 465
 466   return p;
 467 }
 468
 469 #define ADVANCE                                 \
 470   do {                                          \
 471     ++p;                                        \
 472     if (p == limit)                             \
 473       error (_("Malformed escape sequence"));   \
 474   } while (0)
 475
 476 /* Convert an escape sequence to a target format.  TYPE is the target
 477    character type to use, and DEST_CHARSET is the name of the target
 478    character set.  The backslash of the escape sequence is at *P, and
 479    the escape sequence will not extend past LIMIT.  The results are
 480    written to OUTPUT.  Returns a pointer to just past the final
 481    character of the escape sequence.  */
 482
 483 static char *
 484 convert_escape (struct type *type, const char *dest_charset,
 485                 char *p, char *limit, struct obstack *output)
 486 {
 487   /* Skip the backslash.  */
 488   ADVANCE;
 489
 490   switch (*p)
 491     {
 492     case '\\':
 493       obstack_1grow (output, '\\');
 494       ++p;
 495       break;
 496
 497     case 'x':
 498       ADVANCE;
 499       if (!isxdigit (*p))
 500         error (_("\\x used with no following hex digits."));
 501       p = convert_hex (type, p, limit, output);
 502       break;
 503
 504     case '0':
 505     case '1':
 506     case '2':
 507     case '3':
 508     case '4':
 509     case '5':
 510     case '6':
 511     case '7':
 512       p = convert_octal (type, p, limit, output);
 513       break;
 514
 515     case 'u':
 516     case 'U':
 517       {
 518         int length = *p == 'u' ? 4 : 8;
 519
 520         ADVANCE;
 521         if (!isxdigit (*p))
 522           error (_("\\u used with no following hex digits"));
 523         p = convert_ucn (p, limit, dest_charset, output, length);
 524       }
 525     }
 526
 527   return p;
 528 }
 529
 530 /* Given a single string from a (C-specific) OP_STRING list, convert
 531    it to a target string, handling escape sequences specially.  The
 532    output is written to OUTPUT.  DATA is the input string, which has
 533    length LEN.  DEST_CHARSET is the name of the target character set,
 534    and TYPE is the type of target character to use.  */
 535
 536 static void
 537 parse_one_string (struct obstack *output, char *data, int len,
 538                   const char *dest_charset, struct type *type)
 539 {
 540   char *limit;
 541
 542   limit = data + len;
 543
 544   while (data < limit)
 545     {
 546       char *p = data;
 547
 548       /* Look for next escape, or the end of the input.  */
 549       while (p < limit && *p != '\\')
 550         ++p;
 551       /* If we saw a run of characters, convert them all.  */
 552       if (p > data)
 553         convert_between_encodings (host_charset (), dest_charset,
 554                                    (gdb_byte *) data, p - data, 1,
 555                                    output, translit_none);
 556       /* If we saw an escape, convert it.  */
 557       if (p < limit)
 558         p = convert_escape (type, dest_charset, p, limit, output);
 559       data = p;
 560     }
 561 }
 562
 563 /* Expression evaluator for the C language family.  Most operations
 564    are delegated to evaluate_subexp_standard; see that function for a
 565    description of the arguments.  */
 566
 567 struct value *
 568 evaluate_subexp_c (struct type *expect_type, struct expression *exp,
 569                    int *pos, enum noside noside)
 570 {
 571   enum exp_opcode op = exp->elts[*pos].opcode;
 572
 573   switch (op)
 574     {
 575     case OP_STRING:
 576       {
 577         int oplen, limit;
 578         struct type *type;
 579         struct obstack output;
 580         struct cleanup *cleanup;
 581         struct value *result;
 582         enum c_string_type dest_type;
 583         const char *dest_charset;
 584         int satisfy_expected = 0;
 585
 586         obstack_init (&output);
 587         cleanup = make_cleanup_obstack_free (&output);
 588
 589         ++*pos;
 590         oplen = longest_to_int (exp->elts[*pos].longconst);
 591
 592         ++*pos;
 593         limit = *pos + BYTES_TO_EXP_ELEM (oplen + 1);
 594         dest_type
 595           = (enum c_string_type) longest_to_int (exp->elts[*pos].longconst);
 596         switch (dest_type & ~C_CHAR)
 597           {
 598           case C_STRING:
 599             type = language_string_char_type (exp->language_defn,
 600                                               exp->gdbarch);
 601             break;
 602           case C_WIDE_STRING:
 603             type = lookup_typename (exp->language_defn, exp->gdbarch,
 604                                     "wchar_t", NULL, 0);
 605             break;
 606           case C_STRING_16:
 607             type = lookup_typename (exp->language_defn, exp->gdbarch,
 608                                     "char16_t", NULL, 0);
 609             break;
 610           case C_STRING_32:
 611             type = lookup_typename (exp->language_defn, exp->gdbarch,
 612                                     "char32_t", NULL, 0);
 613             break;
 614           default:
 615             internal_error (__FILE__, __LINE__, _("unhandled c_string_type"));
 616           }
 617
 618         /* Ensure TYPE_LENGTH is valid for TYPE.  */
 619         check_typedef (type);
 620
 621         /* If the caller expects an array of some integral type,
 622            satisfy them.  If something odder is expected, rely on the
 623            caller to cast.  */
 624         if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_ARRAY)
 625           {
 626             struct type *element_type
 627               = check_typedef (TYPE_TARGET_TYPE (expect_type));
 628
 629             if (TYPE_CODE (element_type) == TYPE_CODE_INT
 630                 || TYPE_CODE (element_type) == TYPE_CODE_CHAR)
 631               {
 632                 type = element_type;
 633                 satisfy_expected = 1;
 634               }
 635           }
 636
 637         dest_charset = charset_for_string_type (dest_type, exp->gdbarch);
 638
 639         ++*pos;
 640         while (*pos < limit)
 641           {
 642             int len;
 643
 644             len = longest_to_int (exp->elts[*pos].longconst);
 645
 646             ++*pos;
 647             if (noside != EVAL_SKIP)
 648               parse_one_string (&output, &exp->elts[*pos].string, len,
 649                                 dest_charset, type);
 650             *pos += BYTES_TO_EXP_ELEM (len);
 651           }
 652
 653         /* Skip the trailing length and opcode.  */
 654         *pos += 2;
 655
 656         if (noside == EVAL_SKIP)
 657           {
 658             /* Return a dummy value of the appropriate type.  */
 659             if (expect_type != NULL)
 660               result = allocate_value (expect_type);
 661             else if ((dest_type & C_CHAR) != 0)
 662               result = allocate_value (type);
 663             else
 664               result = value_cstring ("", 0, type);
 665             do_cleanups (cleanup);
 666             return result;
 667           }
 668
 669         if ((dest_type & C_CHAR) != 0)
 670           {
 671             LONGEST value;
 672
 673             if (obstack_object_size (&output) != TYPE_LENGTH (type))
 674               error (_("Could not convert character "
 675                        "constant to target character set"));
 676             value = unpack_long (type, (gdb_byte *) obstack_base (&output));
 677             result = value_from_longest (type, value);
 678           }
 679         else
 680           {
 681             int i;
 682
 683             /* Write the terminating character.  */
 684             for (i = 0; i < TYPE_LENGTH (type); ++i)
 685               obstack_1grow (&output, 0);
 686
 687             if (satisfy_expected)
 688               {
 689                 LONGEST low_bound, high_bound;
 690                 int element_size = TYPE_LENGTH (type);
 691
 692                 if (get_discrete_bounds (TYPE_INDEX_TYPE (expect_type),
 693                                          &low_bound, &high_bound) < 0)
 694                   {
 695                     low_bound = 0;
 696                     high_bound = (TYPE_LENGTH (expect_type) / element_size) - 1;
 697                   }
 698                 if (obstack_object_size (&output) / element_size
 699                     > (high_bound - low_bound + 1))
 700                   error (_("Too many array elements"));
 701
 702                 result = allocate_value (expect_type);
 703                 memcpy (value_contents_raw (result), obstack_base (&output),
 704                         obstack_object_size (&output));
 705               }
 706             else
 707               result = value_cstring (obstack_base (&output),
 708                                       obstack_object_size (&output),
 709                                       type);
 710           }
 711         do_cleanups (cleanup);
 712         return result;
 713       }
 714       break;
 715
 716     default:
 717       break;
 718     }
 719   return evaluate_subexp_standard (expect_type, exp, pos, noside);
 720 }
 721
 722
 723 \f
 724 /* Table mapping opcodes into strings for printing operators
 725    and precedences of the operators.  */
 726
 727 const struct op_print c_op_print_tab[] =
 728 {
 729   {",", BINOP_COMMA, PREC_COMMA, 0},
 730   {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
 731   {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
 732   {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
 733   {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
 734   {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
 735   {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
 736   {"==", BINOP_EQUAL, PREC_EQUAL, 0},
 737   {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
 738   {"<=", BINOP_LEQ, PREC_ORDER, 0},
 739   {">=", BINOP_GEQ, PREC_ORDER, 0},
 740   {">", BINOP_GTR, PREC_ORDER, 0},
 741   {"<", BINOP_LESS, PREC_ORDER, 0},
 742   {">>", BINOP_RSH, PREC_SHIFT, 0},
 743   {"<<", BINOP_LSH, PREC_SHIFT, 0},
 744   {"+", BINOP_ADD, PREC_ADD, 0},
 745   {"-", BINOP_SUB, PREC_ADD, 0},
 746   {"*", BINOP_MUL, PREC_MUL, 0},
 747   {"/", BINOP_DIV, PREC_MUL, 0},
 748   {"%", BINOP_REM, PREC_MUL, 0},
 749   {"@", BINOP_REPEAT, PREC_REPEAT, 0},
 750   {"+", UNOP_PLUS, PREC_PREFIX, 0},
 751   {"-", UNOP_NEG, PREC_PREFIX, 0},
 752   {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
 753   {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
 754   {"*", UNOP_IND, PREC_PREFIX, 0},
 755   {"&", UNOP_ADDR, PREC_PREFIX, 0},
 756   {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
 757   {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
 758   {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
 759   {NULL, 0, 0, 0}
 760 };
 761 \f
 762 enum c_primitive_types {
 763   c_primitive_type_int,
 764   c_primitive_type_long,
 765   c_primitive_type_short,
 766   c_primitive_type_char,
 767   c_primitive_type_float,
 768   c_primitive_type_double,
 769   c_primitive_type_void,
 770   c_primitive_type_long_long,
 771   c_primitive_type_signed_char,
 772   c_primitive_type_unsigned_char,
 773   c_primitive_type_unsigned_short,
 774   c_primitive_type_unsigned_int,
 775   c_primitive_type_unsigned_long,
 776   c_primitive_type_unsigned_long_long,
 777   c_primitive_type_long_double,
 778   c_primitive_type_complex,
 779   c_primitive_type_double_complex,
 780   c_primitive_type_decfloat,
 781   c_primitive_type_decdouble,
 782   c_primitive_type_declong,
 783   nr_c_primitive_types
 784 };
 785
 786 void
 787 c_language_arch_info (struct gdbarch *gdbarch,
 788                       struct language_arch_info *lai)
 789 {
 790   const struct builtin_type *builtin = builtin_type (gdbarch);
 791
 792   lai->string_char_type = builtin->builtin_char;
 793   lai->primitive_type_vector
 794     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1,
 795                               struct type *);
 796   lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int;
 797   lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long;
 798   lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short;
 799   lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char;
 800   lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float;
 801   lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double;
 802   lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void;
 803   lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long;
 804   lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char;
 805   lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char;
 806   lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short;
 807   lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int;
 808   lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long;
 809   lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long;
 810   lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double;
 811   lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex;
 812   lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex;
 813   lai->primitive_type_vector [c_primitive_type_decfloat] = builtin->builtin_decfloat;
 814   lai->primitive_type_vector [c_primitive_type_decdouble] = builtin->builtin_decdouble;
 815   lai->primitive_type_vector [c_primitive_type_declong] = builtin->builtin_declong;
 816
 817   lai->bool_type_default = builtin->builtin_int;
 818 }
 819
 820 const struct exp_descriptor exp_descriptor_c =
 821 {
 822   print_subexp_standard,
 823   operator_length_standard,
 824   operator_check_standard,
 825   op_name_standard,
 826   dump_subexp_body_standard,
 827   evaluate_subexp_c
 828 };
 829
 830 const struct language_defn c_language_defn =
 831 {
 832   "c",                          /* Language name */
 833   "C",
 834   language_c,
 835   range_check_off,
 836   case_sensitive_on,
 837   array_row_major,
 838   macro_expansion_c,
 839   &exp_descriptor_c,
 840   c_parse,
 841   c_error,
 842   null_post_parser,
 843   c_printchar,                  /* Print a character constant */
 844   c_printstr,                   /* Function to print string constant */
 845   c_emit_char,                  /* Print a single char */
 846   c_print_type,                 /* Print a type using appropriate syntax */
 847   c_print_typedef,              /* Print a typedef using appropriate syntax */
 848   c_val_print,                  /* Print a value using appropriate syntax */
 849   c_value_print,                /* Print a top-level value */
 850   default_read_var_value,       /* la_read_var_value */
 851   NULL,                         /* Language specific skip_trampoline */
 852   NULL,                         /* name_of_this */
 853   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 854   basic_lookup_transparent_type,/* lookup_transparent_type */
 855   NULL,                         /* Language specific symbol demangler */
 856   NULL,                         /* Language specific
 857                                    class_name_from_physname */
 858   c_op_print_tab,               /* expression operators for printing */
 859   1,                            /* c-style arrays */
 860   0,                            /* String lower bound */
 861   default_word_break_characters,
 862   default_make_symbol_completion_list,
 863   c_language_arch_info,
 864   default_print_array_index,
 865   default_pass_by_reference,
 866   c_get_string,
 867   NULL,                         /* la_get_symbol_name_cmp */
 868   iterate_over_symbols,
 869   &c_varobj_ops,
 870   LANG_MAGIC
 871 };
 872
 873 enum cplus_primitive_types {
 874   cplus_primitive_type_int,
 875   cplus_primitive_type_long,
 876   cplus_primitive_type_short,
 877   cplus_primitive_type_char,
 878   cplus_primitive_type_float,
 879   cplus_primitive_type_double,
 880   cplus_primitive_type_void,
 881   cplus_primitive_type_long_long,
 882   cplus_primitive_type_signed_char,
 883   cplus_primitive_type_unsigned_char,
 884   cplus_primitive_type_unsigned_short,
 885   cplus_primitive_type_unsigned_int,
 886   cplus_primitive_type_unsigned_long,
 887   cplus_primitive_type_unsigned_long_long,
 888   cplus_primitive_type_long_double,
 889   cplus_primitive_type_complex,
 890   cplus_primitive_type_double_complex,
 891   cplus_primitive_type_bool,
 892   cplus_primitive_type_decfloat,
 893   cplus_primitive_type_decdouble,
 894   cplus_primitive_type_declong,
 895   nr_cplus_primitive_types
 896 };
 897
 898 static void
 899 cplus_language_arch_info (struct gdbarch *gdbarch,
 900                           struct language_arch_info *lai)
 901 {
 902   const struct builtin_type *builtin = builtin_type (gdbarch);
 903
 904   lai->string_char_type = builtin->builtin_char;
 905   lai->primitive_type_vector
 906     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1,
 907                               struct type *);
 908   lai->primitive_type_vector [cplus_primitive_type_int]
 909     = builtin->builtin_int;
 910   lai->primitive_type_vector [cplus_primitive_type_long]
 911     = builtin->builtin_long;
 912   lai->primitive_type_vector [cplus_primitive_type_short]
 913     = builtin->builtin_short;
 914   lai->primitive_type_vector [cplus_primitive_type_char]
 915     = builtin->builtin_char;
 916   lai->primitive_type_vector [cplus_primitive_type_float]
 917     = builtin->builtin_float;
 918   lai->primitive_type_vector [cplus_primitive_type_double]
 919     = builtin->builtin_double;
 920   lai->primitive_type_vector [cplus_primitive_type_void]
 921     = builtin->builtin_void;
 922   lai->primitive_type_vector [cplus_primitive_type_long_long]
 923     = builtin->builtin_long_long;
 924   lai->primitive_type_vector [cplus_primitive_type_signed_char]
 925     = builtin->builtin_signed_char;
 926   lai->primitive_type_vector [cplus_primitive_type_unsigned_char]
 927     = builtin->builtin_unsigned_char;
 928   lai->primitive_type_vector [cplus_primitive_type_unsigned_short]
 929     = builtin->builtin_unsigned_short;
 930   lai->primitive_type_vector [cplus_primitive_type_unsigned_int]
 931     = builtin->builtin_unsigned_int;
 932   lai->primitive_type_vector [cplus_primitive_type_unsigned_long]
 933     = builtin->builtin_unsigned_long;
 934   lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long]
 935     = builtin->builtin_unsigned_long_long;
 936   lai->primitive_type_vector [cplus_primitive_type_long_double]
 937     = builtin->builtin_long_double;
 938   lai->primitive_type_vector [cplus_primitive_type_complex]
 939     = builtin->builtin_complex;
 940   lai->primitive_type_vector [cplus_primitive_type_double_complex]
 941     = builtin->builtin_double_complex;
 942   lai->primitive_type_vector [cplus_primitive_type_bool]
 943     = builtin->builtin_bool;
 944   lai->primitive_type_vector [cplus_primitive_type_decfloat]
 945     = builtin->builtin_decfloat;
 946   lai->primitive_type_vector [cplus_primitive_type_decdouble]
 947     = builtin->builtin_decdouble;
 948   lai->primitive_type_vector [cplus_primitive_type_declong]
 949     = builtin->builtin_declong;
 950
 951   lai->bool_type_symbol = "bool";
 952   lai->bool_type_default = builtin->builtin_bool;
 953 }
 954
 955 const struct language_defn cplus_language_defn =
 956 {
 957   "c++",                        /* Language name */
 958   "C++",
 959   language_cplus,
 960   range_check_off,
 961   case_sensitive_on,
 962   array_row_major,
 963   macro_expansion_c,
 964   &exp_descriptor_c,
 965   c_parse,
 966   c_error,
 967   null_post_parser,
 968   c_printchar,                  /* Print a character constant */
 969   c_printstr,                   /* Function to print string constant */
 970   c_emit_char,                  /* Print a single char */
 971   c_print_type,                 /* Print a type using appropriate syntax */
 972   c_print_typedef,              /* Print a typedef using appropriate syntax */
 973   c_val_print,                  /* Print a value using appropriate syntax */
 974   c_value_print,                /* Print a top-level value */
 975   default_read_var_value,       /* la_read_var_value */
 976   cplus_skip_trampoline,        /* Language specific skip_trampoline */
 977   "this",                       /* name_of_this */
 978   cp_lookup_symbol_nonlocal,    /* lookup_symbol_nonlocal */
 979   cp_lookup_transparent_type,   /* lookup_transparent_type */
 980   gdb_demangle,                 /* Language specific symbol demangler */
 981   cp_class_name_from_physname,  /* Language specific
 982                                    class_name_from_physname */
 983   c_op_print_tab,               /* expression operators for printing */
 984   1,                            /* c-style arrays */
 985   0,                            /* String lower bound */
 986   default_word_break_characters,
 987   default_make_symbol_completion_list,
 988   cplus_language_arch_info,
 989   default_print_array_index,
 990   cp_pass_by_reference,
 991   c_get_string,
 992   NULL,                         /* la_get_symbol_name_cmp */
 993   iterate_over_symbols,
 994   &cplus_varobj_ops,
 995   LANG_MAGIC
 996 };
 997
 998 const struct language_defn asm_language_defn =
 999 {
1000   "asm",                        /* Language name */
1001   "assembly",
1002   language_asm,
1003   range_check_off,
1004   case_sensitive_on,
1005   array_row_major,
1006   macro_expansion_c,
1007   &exp_descriptor_c,
1008   c_parse,
1009   c_error,
1010   null_post_parser,
1011   c_printchar,                  /* Print a character constant */
1012   c_printstr,                   /* Function to print string constant */
1013   c_emit_char,                  /* Print a single char */
1014   c_print_type,                 /* Print a type using appropriate syntax */
1015   c_print_typedef,              /* Print a typedef using appropriate syntax */
1016   c_val_print,                  /* Print a value using appropriate syntax */
1017   c_value_print,                /* Print a top-level value */
1018   default_read_var_value,       /* la_read_var_value */
1019   NULL,                         /* Language specific skip_trampoline */
1020   NULL,                         /* name_of_this */
1021   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1022   basic_lookup_transparent_type,/* lookup_transparent_type */
1023   NULL,                         /* Language specific symbol demangler */
1024   NULL,                         /* Language specific
1025                                    class_name_from_physname */
1026   c_op_print_tab,               /* expression operators for printing */
1027   1,                            /* c-style arrays */
1028   0,                            /* String lower bound */
1029   default_word_break_characters,
1030   default_make_symbol_completion_list,
1031   c_language_arch_info,         /* FIXME: la_language_arch_info.  */
1032   default_print_array_index,
1033   default_pass_by_reference,
1034   c_get_string,
1035   NULL,                         /* la_get_symbol_name_cmp */
1036   iterate_over_symbols,
1037   &default_varobj_ops,
1038   LANG_MAGIC
1039 };
1040
1041 /* The following language_defn does not represent a real language.
1042    It just provides a minimal support a-la-C that should allow users
1043    to do some simple operations when debugging applications that use
1044    a language currently not supported by GDB.  */
1045
1046 const struct language_defn minimal_language_defn =
1047 {
1048   "minimal",                    /* Language name */
1049   "Minimal",
1050   language_minimal,
1051   range_check_off,
1052   case_sensitive_on,
1053   array_row_major,
1054   macro_expansion_c,
1055   &exp_descriptor_c,
1056   c_parse,
1057   c_error,
1058   null_post_parser,
1059   c_printchar,                  /* Print a character constant */
1060   c_printstr,                   /* Function to print string constant */
1061   c_emit_char,                  /* Print a single char */
1062   c_print_type,                 /* Print a type using appropriate syntax */
1063   c_print_typedef,              /* Print a typedef using appropriate syntax */
1064   c_val_print,                  /* Print a value using appropriate syntax */
1065   c_value_print,                /* Print a top-level value */
1066   default_read_var_value,       /* la_read_var_value */
1067   NULL,                         /* Language specific skip_trampoline */
1068   NULL,                         /* name_of_this */
1069   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1070   basic_lookup_transparent_type,/* lookup_transparent_type */
1071   NULL,                         /* Language specific symbol demangler */
1072   NULL,                         /* Language specific
1073                                    class_name_from_physname */
1074   c_op_print_tab,               /* expression operators for printing */
1075   1,                            /* c-style arrays */
1076   0,                            /* String lower bound */
1077   default_word_break_characters,
1078   default_make_symbol_completion_list,
1079   c_language_arch_info,
1080   default_print_array_index,
1081   default_pass_by_reference,
1082   c_get_string,
1083   NULL,                         /* la_get_symbol_name_cmp */
1084   iterate_over_symbols,
1085   &default_varobj_ops,
1086   LANG_MAGIC
1087 };
1088
1089 void
1090 _initialize_c_language (void)
1091 {
1092   add_language (&c_language_defn);
1093   add_language (&cplus_language_defn);
1094   add_language (&asm_language_defn);
1095   add_language (&minimal_language_defn);
1096 }