Update read1 example in gdb/testsuite/README

[binutils-gdb.git] / gdb / std-operator.def

diff --git a/gdb/std-operator.def b/gdb/std-operator.def
index e969bdccaed8fd6855458e669fca7290046ad40d..9dde7bab2c9255f4c9bdc5e83f43d95ff4afb52d 100644 (file)
--- a/gdb/std-operator.def
+++ b/gdb/std-operator.def
@@ -1,6 +1,6 @@
 /* Standard language operator definitions for GDB, the GNU debugger.
 
-   Copyright (C) 1986-2020 Free Software Foundation, Inc.
+   Copyright (C) 1986-2021 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -87,9 +87,6 @@ OP (BINOP_VAL)
    the second operand with itself that many times.  */
 OP (BINOP_CONCAT)
 
-/* This must be the highest BINOP_ value, for expprint.c.  */
-OP (BINOP_END)
-
 /* Operates on three values computed by following subexpressions.  */
 OP (TERNOP_COND)               /* ?: */
 
@@ -168,14 +165,6 @@ OP (OP_FUNCALL)
    pointer.  This is an Objective C message.  */
 OP (OP_OBJC_MSGCALL)
 
-/* This is EXACTLY like OP_FUNCALL but is semantically different.
-   In F77, array subscript expressions, substring expressions and
-   function calls are all exactly the same syntactically.  They
-   may only be disambiguated at runtime.  Thus this operator,
-   which indicates that we have found something of the form
-   <name> ( <stuff> ).  */
-OP (OP_F77_UNDETERMINED_ARGLIST)
-
 /* OP_COMPLEX takes a type in the following element, followed by another
    OP_COMPLEX, making three exp_elements.  It is followed by two double
    args, and converts them into a complex number of the given type.  */
@@ -238,19 +227,10 @@ OP (UNOP_ALIGNOF)         /* Unary alignof (followed by expression) */
 
 OP (UNOP_PLUS)                 /* Unary plus */
 
-OP (UNOP_CAP)                  /* Modula-2 standard (unary) procedures */
-OP (UNOP_CHR)
-OP (UNOP_ORD)
 OP (UNOP_ABS)
-OP (UNOP_FLOAT)
 OP (UNOP_HIGH)
-OP (UNOP_MAX)
-OP (UNOP_MIN)
-OP (UNOP_ODD)
-OP (UNOP_TRUNC)
 
 OP (OP_BOOL)                   /* Modula-2 builtin BOOLEAN type */
-OP (OP_M2_STRING)              /* Modula-2 string constants */
 
 /* STRUCTOP_... operate on a value from a following subexpression
    by extracting a structure component specified by a string
@@ -316,9 +296,6 @@ OP (OP_FUNC_STATIC_VAR)
    the GDB "::" operator, or the Modula-2 '.' operator.  */
 OP (OP_TYPE)
 
-/* An un-looked-up identifier.  */
-OP (OP_NAME)
-
 /* An Objective C Foundation Class NSString constant.  */
 OP (OP_OBJC_NSSTRING)
 
@@ -345,3 +322,72 @@ OP (OP_TYPEID)
 /* This is used for the Rust [expr; N] form of array construction.  It
    takes two expression arguments.  */
 OP (OP_RUST_ARRAY)
+
+/* ================ Ada operators ================ */
+
+/* X IN A'RANGE(N).  N is an immediate operand, surrounded by 
+   BINOP_IN_BOUNDS before and after.  A is an array, X an index 
+   value.  Evaluates to true iff X is within range of the Nth
+   dimension (1-based) of A.  (A multi-dimensional array
+   type is represented as array of array of ...) */
+OP (BINOP_IN_BOUNDS)
+
+/* X IN L .. U.  True iff L <= X <= U.  */
+OP (TERNOP_IN_RANGE)
+
+/* Ada attributes ('Foo). */
+OP (OP_ATR_FIRST)
+OP (OP_ATR_LAST)
+OP (OP_ATR_LENGTH)
+OP (OP_ATR_POS)
+OP (OP_ATR_SIZE)
+OP (OP_ATR_TAG)
+OP (OP_ATR_VAL)
+
+/* Ada type qualification.  It is encoded as for UNOP_CAST, above, 
+   and denotes the TYPE'(EXPR) construct. */
+OP (UNOP_QUAL)
+
+/* X IN TYPE.  The `TYPE' argument is immediate, with 
+   UNOP_IN_RANGE before and after it. True iff X is a member of 
+   type TYPE (typically a subrange). */
+OP (UNOP_IN_RANGE)
+
+/* An aggregate.   A single immediate operand, N>0, gives
+   the number of component specifications that follow.  The
+   immediate operand is followed by a second OP_AGGREGATE.  
+   Next come N component specifications.  A component
+   specification is either an OP_OTHERS (others=>...), an
+   OP_CHOICES (for named associations), or other expression (for
+   positional aggregates only).  Aggregates currently
+   occur only as the right sides of assignments. */
+OP (OP_AGGREGATE)
+
+/* ================ Fortran operators ================ */
+
+/* This is EXACTLY like OP_FUNCALL but is semantically different.
+   In F77, array subscript expressions, substring expressions and
+   function calls are all exactly the same syntactically.  They
+   may only be disambiguated at runtime.  Thus this operator,
+   which indicates that we have found something of the form
+   <name> ( <stuff> ).  */
+OP (OP_F77_UNDETERMINED_ARGLIST)
+
+/* Single operand builtins.  */
+OP (UNOP_FORTRAN_KIND)
+OP (UNOP_FORTRAN_FLOOR)
+OP (UNOP_FORTRAN_CEILING)
+OP (UNOP_FORTRAN_ALLOCATED)
+OP (UNOP_FORTRAN_RANK)
+OP (UNOP_FORTRAN_SHAPE)
+OP (UNOP_FORTRAN_LOC)
+
+/* Two operand builtins.  */
+OP (BINOP_FORTRAN_CMPLX)
+OP (BINOP_FORTRAN_MODULO)
+
+/* Builtins that take one or two operands.  */
+OP (FORTRAN_LBOUND)
+OP (FORTRAN_UBOUND)
+OP (FORTRAN_ASSOCIATED)
+OP (FORTRAN_ARRAY_SIZE)