Imported Upstream version 7.9

[platform/upstream/gdb.git] / gdb / std-operator.def

diff --git a/gdb/std-operator.def b/gdb/std-operator.def
index f2f650b..f51dda7 100644 (file)
--- a/gdb/std-operator.def
+++ b/gdb/std-operator.def
@@ -1,7 +1,6 @@
 /* Standard language operator definitions for GDB, the GNU debugger.
 
-   Copyright (C) 1986, 1989, 1992, 1994, 2000, 2003, 2005, 2007-2012
-   Free Software Foundation, Inc.
+   Copyright (C) 1986-2015 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -88,28 +87,16 @@ OP (BINOP_VAL)
    the second operand with itself that many times.  */
 OP (BINOP_CONCAT)
 
-/* For (the deleted) Chill and Pascal.  */
-OP (BINOP_IN)                  /* Returns 1 iff ARG1 IN ARG2.  */
-
-/* This is the "colon operator" used various places in (the
-   deleted) Chill.  */
-OP (BINOP_RANGE)
-
 /* This must be the highest BINOP_ value, for expprint.c.  */
 OP (BINOP_END)
 
 /* Operates on three values computed by following subexpressions.  */
 OP (TERNOP_COND)               /* ?: */
 
-/* A sub-string/sub-array.  (the deleted) Chill syntax:
-   OP1(OP2:OP3).  Return elements OP2 through OP3 of OP1.  */
+/* A sub-string/sub-array.  Ada syntax: OP1(OP2..OP3).  Return
+   elements OP2 through OP3 of OP1.  */
 OP (TERNOP_SLICE)
 
-/* A sub-string/sub-array.  (The deleted) Chill syntax: OP1(OP2 UP
-   OP3).  Return OP3 elements of OP1, starting with element
-   OP2.  */
-OP (TERNOP_SLICE_COUNT)
-
 /* Multidimensional subscript operator, such as Modula-2 x[a,b,...].
    The dimensionality is encoded in the operator, like the number of
    function arguments in OP_FUNCALL, I.E. <OP><dimension><OP>.
@@ -194,12 +181,6 @@ OP (OP_COMPLEX)
    is executed.  */
 OP (OP_STRING)
 
-/* OP_BITSTRING represents a packed bitstring constant.
-   Its format is the same as that of a STRUCTOP, but the bitstring
-   data is just made into a bitstring constant when the operation
-   is executed.  */
-OP (OP_BITSTRING)
-
 /* OP_ARRAY creates an array constant out of the following subexpressions.
    It is followed by two exp_elements, the first containing an integer
    that is the lower bound of the array and the second containing another
@@ -216,6 +197,9 @@ OP (OP_ARRAY)
    It casts the value of the following subexpression.  */
 OP (UNOP_CAST)
 
+/* Like UNOP_CAST, but the type is a subexpression.  */
+OP (UNOP_CAST_TYPE)
+
 /* The C++ dynamic_cast operator.  */
 OP (UNOP_DYNAMIC_CAST)
 
@@ -235,6 +219,9 @@ OP (UNOP_MEMVAL)
    following subexpression from the TLS specified by `struct objfile'.  */
 OP (UNOP_MEMVAL_TLS)
 
+/* Like UNOP_MEMVAL, but the type is supplied as a subexpression.  */
+OP (UNOP_MEMVAL_TYPE)
+
 /* UNOP_... operate on one value from a following subexpression
    and replace it with a result.  They take no immediate arguments.  */
 
@@ -291,19 +278,6 @@ OP (OP_OBJC_SELECTOR)
    a string, which, of course, is variable length.  */
 OP (OP_SCOPE)
 
-/* Used to represent named structure field values in brace
-   initializers (or tuples as they are called in (the deleted)
-   Chill).
-
-   The gcc C syntax is NAME:VALUE or .NAME=VALUE, the (the
-   deleted) Chill syntax is .NAME:VALUE.  Multiple labels (as in
-   the (the deleted) Chill syntax .NAME1,.NAME2:VALUE) is
-   represented as if it were .NAME1:(.NAME2:VALUE) (though that is
-   not valid (the deleted) Chill syntax).
-
-   The NAME is represented as for STRUCTOP_STRUCT;  VALUE follows.  */
-OP (OP_LABELED)
-
 /* OP_TYPE is for parsing types, and used with the "ptype" command
    so we can look up types that are qualified by scope, either with
    the GDB "::" operator, or the Modula-2 '.' operator.  */
@@ -326,3 +300,15 @@ OP (OP_DECFLOAT)
 /* OP_ADL_FUNC specifies that the function is to be looked up in an
    Argument Dependent manner (Koenig lookup).  */
 OP (OP_ADL_FUNC)
+
+/* The typeof operator.  This has one expression argument, which is
+   evaluated solely for its type.  */
+OP (OP_TYPEOF)
+
+/* The decltype operator.  This has one expression argument, which is
+   evaluated solely for its type.  This is similar to typeof, but has
+   slight different semantics.  */
+OP (OP_DECLTYPE)
+
+/* The typeid operator.  This has one expression argument.  */
+OP (OP_TYPEID)