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