Add inclusive range support for Rust

[deliverable/binutils-gdb.git] / gdb / expprint.c

diff --git a/gdb/expprint.c b/gdb/expprint.c
index 0697a773b9d09231e1580dedea7b761c29714ddb..047ec11df1929b73efee131538b4df56237735aa 100644 (file)
--- a/gdb/expprint.c
+++ b/gdb/expprint.c
@@ -1,6 +1,6 @@
 /* Print in infix form a struct expression.
 
-   Copyright (C) 1986-2017 Free Software Foundation, Inc.
+   Copyright (C) 1986-2018 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -105,14 +105,14 @@ print_subexp_standard (struct expression *exp, int *pos,
       }
       return;
 
-    case OP_DOUBLE:
+    case OP_FLOAT:
       {
        struct value_print_options opts;
 
        get_no_prettyformat_print_options (&opts);
        (*pos) += 3;
-       value_print (value_from_double (exp->elts[pc + 1].type,
-                                       exp->elts[pc + 2].doubleconst),
+       value_print (value_from_contents (exp->elts[pc + 1].type,
+                                         exp->elts[pc + 2].floatconst),
                     stream, &opts);
       }
       return;
@@ -141,6 +141,14 @@ print_subexp_standard (struct expression *exp, int *pos,
       }
       return;
 
+    case OP_FUNC_STATIC_VAR:
+      {
+       tem = longest_to_int (exp->elts[pc + 1].longconst);
+       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
+       fputs_filtered (&exp->elts[pc + 1].string, stream);
+      }
+      return;
+
     case OP_VAR_ENTRY_VALUE:
       {
        (*pos) += 2;
@@ -178,6 +186,7 @@ print_subexp_standard (struct expression *exp, int *pos,
       return;
 
     case OP_FUNCALL:
+    case OP_F77_UNDETERMINED_ARGLIST:
       (*pos) += 2;
       nargs = longest_to_int (exp->elts[pc + 1].longconst);
       print_subexp (exp, pos, stream, PREC_SUFFIX);
@@ -231,7 +240,7 @@ print_subexp_standard (struct expression *exp, int *pos,
 
     case OP_OBJC_MSGCALL:
       {                        /* Objective C message (method) call.  */
-       char *selector;
+       gdb::unique_xmalloc_ptr<char> selector;
 
        (*pos) += 3;
        nargs = longest_to_int (exp->elts[pc + 2].longconst);
@@ -247,8 +256,7 @@ print_subexp_standard (struct expression *exp, int *pos,
          {
            char *s, *nextS;
 
-           s = (char *) alloca (strlen (selector) + 1);
-           strcpy (s, selector);
+           s = selector.get ();
            for (tem = 0; tem < nargs; tem++)
              {
                nextS = strchr (s, ':');
@@ -261,11 +269,9 @@ print_subexp_standard (struct expression *exp, int *pos,
          }
        else
          {
-           fprintf_unfiltered (stream, " %s", selector);
+           fprintf_unfiltered (stream, " %s", selector.get ());
          }
        fprintf_unfiltered (stream, "]");
-       /* "selector" was malloc'd by target_read_string.  Free it.  */
-       xfree (selector);
        return;
       }
 
@@ -535,11 +541,15 @@ print_subexp_standard (struct expression *exp, int *pos,
 
     case TYPE_INSTANCE:
       {
-       LONGEST count = exp->elts[pc + 1].longconst;
+       type_instance_flags flags
+         = (type_instance_flag_value) longest_to_int (exp->elts[pc + 1].longconst);
+       LONGEST count = exp->elts[pc + 2].longconst;
 
+       /* The FLAGS.  */
+       (*pos)++;
        /* The COUNT.  */
        (*pos)++;
-       fputs_unfiltered ("TypesInstance(", stream);
+       fputs_unfiltered ("TypeInstance(", stream);
        while (count-- > 0)
          {
            type_print (exp->elts[(*pos)++].type, "", stream, 0);
@@ -550,6 +560,12 @@ print_subexp_standard (struct expression *exp, int *pos,
        /* Ending COUNT and ending TYPE_INSTANCE.  */
        (*pos) += 2;
        print_subexp (exp, pos, stream, PREC_PREFIX);
+
+       if (flags & TYPE_INSTANCE_FLAG_CONST)
+         fputs_unfiltered (",const", stream);
+       if (flags & TYPE_INSTANCE_FLAG_VOLATILE)
+         fputs_unfiltered (",volatile", stream);
+
        fputs_unfiltered (")", stream);
        return;
       }
@@ -562,9 +578,13 @@ print_subexp_standard (struct expression *exp, int *pos,
          longest_to_int (exp->elts[pc + 1].longconst);
        *pos += 2;
 
+       if (range_type == NONE_BOUND_DEFAULT_EXCLUSIVE
+           || range_type == LOW_BOUND_DEFAULT_EXCLUSIVE)
+         fputs_filtered ("EXCLUSIVE_", stream);
        fputs_filtered ("RANGE(", stream);
        if (range_type == HIGH_BOUND_DEFAULT
-           || range_type == NONE_BOUND_DEFAULT)
+           || range_type == NONE_BOUND_DEFAULT
+           || range_type == NONE_BOUND_DEFAULT_EXCLUSIVE)
          print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
        fputs_filtered ("..", stream);
        if (range_type == LOW_BOUND_DEFAULT
@@ -853,13 +873,14 @@ dump_subexp_body_standard (struct expression *exp,
                        (long) exp->elts[elt + 1].longconst);
       elt += 3;
       break;
-    case OP_DOUBLE:
+    case OP_FLOAT:
       fprintf_filtered (stream, "Type @");
       gdb_print_host_address (exp->elts[elt].type, stream);
       fprintf_filtered (stream, " (");
       type_print (exp->elts[elt].type, NULL, stream, 0);
-      fprintf_filtered (stream, "), value %g",
-                       (double) exp->elts[elt + 1].doubleconst);
+      fprintf_filtered (stream, "), value ");
+      print_floating (exp->elts[elt + 1].floatconst,
+                     exp->elts[elt].type, stream);
       elt += 3;
       break;
     case OP_VAR_VALUE:
@@ -904,6 +925,7 @@ dump_subexp_body_standard (struct expression *exp,
       elt += 2;
       break;
     case OP_FUNCALL:
+    case OP_F77_UNDETERMINED_ARGLIST:
       {
        int i, nargs;
 
@@ -999,11 +1021,21 @@ dump_subexp_body_standard (struct expression *exp,
        elt += 4 + BYTES_TO_EXP_ELEM (len + 1);
       }
       break;
-    case TYPE_INSTANCE:
+
+    case OP_FUNC_STATIC_VAR:
       {
-       LONGEST len;
+       int len = longest_to_int (exp->elts[elt].longconst);
+       const char *var_name = &exp->elts[elt + 1].string;
+       fprintf_filtered (stream, "Field name: `%.*s'", len, var_name);
+       elt += 3 + BYTES_TO_EXP_ELEM (len + 1);
+      }
+      break;
 
-       len = exp->elts[elt++].longconst;
+    case TYPE_INSTANCE:
+      {
+       type_instance_flags flags
+         = (type_instance_flag_value) longest_to_int (exp->elts[elt++].longconst);
+       LONGEST len = exp->elts[elt++].longconst;
        fprintf_filtered (stream, "%s TypeInstance: ", plongest (len));
        while (len-- > 0)
          {
@@ -1016,6 +1048,22 @@ dump_subexp_body_standard (struct expression *exp,
            if (len > 0)
              fputs_filtered (", ", stream);
          }
+
+       fprintf_filtered (stream, " Flags: %s (", hex_string (flags));
+       bool space = false;
+       auto print_one = [&] (const char *mod)
+         {
+           if (space)
+             fputs_filtered (" ", stream);
+           space = true;
+           fprintf_filtered (stream, "%s", mod);
+         };
+       if (flags & TYPE_INSTANCE_FLAG_CONST)
+         print_one ("const");
+       if (flags & TYPE_INSTANCE_FLAG_VOLATILE)
+         print_one ("volatile");
+       fprintf_filtered (stream, ")");
+
        /* Ending LEN and ending TYPE_INSTANCE.  */
        elt += 2;
        elt = dump_subexp (exp, stream, elt);
@@ -1055,12 +1103,18 @@ dump_subexp_body_standard (struct expression *exp,
          case LOW_BOUND_DEFAULT:
            fputs_filtered ("Range '..EXP'", stream);
            break;
+         case LOW_BOUND_DEFAULT_EXCLUSIVE:
+           fputs_filtered ("ExclusiveRange '..EXP'", stream);
+           break;
          case HIGH_BOUND_DEFAULT:
            fputs_filtered ("Range 'EXP..'", stream);
            break;
          case NONE_BOUND_DEFAULT:
            fputs_filtered ("Range 'EXP..EXP'", stream);
            break;
+         case NONE_BOUND_DEFAULT_EXCLUSIVE:
+           fputs_filtered ("ExclusiveRange 'EXP..EXP'", stream);
+           break;
          default:
            fputs_filtered ("Invalid Range!", stream);
            break;
@@ -1078,7 +1132,6 @@ dump_subexp_body_standard (struct expression *exp,
     default:
     case OP_NULL:
     case MULTI_SUBSCRIPT:
-    case OP_F77_UNDETERMINED_ARGLIST:
     case OP_COMPLEX:
     case OP_BOOL:
     case OP_M2_STRING: