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