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