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