1 /* Definitions for Ada expressions
3 Copyright (C) 2020 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
25 extern struct value
*ada_unop_neg (struct type
*expect_type
,
26 struct expression
*exp
,
27 enum noside noside
, enum exp_opcode op
,
29 extern struct value
*ada_atr_tag (struct type
*expect_type
,
30 struct expression
*exp
,
31 enum noside noside
, enum exp_opcode op
,
33 extern struct value
*ada_atr_size (struct type
*expect_type
,
34 struct expression
*exp
,
35 enum noside noside
, enum exp_opcode op
,
37 extern struct value
*ada_abs (struct type
*expect_type
,
38 struct expression
*exp
,
39 enum noside noside
, enum exp_opcode op
,
41 extern struct value
*ada_unop_in_range (struct type
*expect_type
,
42 struct expression
*exp
,
43 enum noside noside
, enum exp_opcode op
,
44 struct value
*arg1
, struct type
*type
);
45 extern struct value
*ada_mult_binop (struct type
*expect_type
,
46 struct expression
*exp
,
47 enum noside noside
, enum exp_opcode op
,
48 struct value
*arg1
, struct value
*arg2
);
49 extern struct value
*ada_equal_binop (struct type
*expect_type
,
50 struct expression
*exp
,
51 enum noside noside
, enum exp_opcode op
,
52 struct value
*arg1
, struct value
*arg2
);
57 /* In Ada, some generic operations must be wrapped with a handler that
58 handles some Ada-specific type conversions. */
59 class ada_wrapped_operation
60 : public tuple_holding_operation
<operation_up
>
64 using tuple_holding_operation::tuple_holding_operation
;
66 value
*evaluate (struct type
*expect_type
,
67 struct expression
*exp
,
68 enum noside noside
) override
;
70 enum exp_opcode
opcode () const override
71 { return std::get
<0> (m_storage
)->opcode (); }
74 /* An Ada string constant. */
75 class ada_string_operation
76 : public string_operation
80 using string_operation::string_operation
;
82 value
*evaluate (struct type
*expect_type
,
83 struct expression
*exp
,
84 enum noside noside
) override
;
87 /* The Ada TYPE'(EXP) construct. */
88 class ada_qual_operation
89 : public tuple_holding_operation
<operation_up
, struct type
*>
93 using tuple_holding_operation::tuple_holding_operation
;
95 value
*evaluate (struct type
*expect_type
,
96 struct expression
*exp
,
97 enum noside noside
) override
;
99 enum exp_opcode
opcode () const override
100 { return UNOP_QUAL
; }
103 /* Ternary in-range operator. */
104 class ada_ternop_range_operation
105 : public tuple_holding_operation
<operation_up
, operation_up
, operation_up
>
109 using tuple_holding_operation::tuple_holding_operation
;
111 value
*evaluate (struct type
*expect_type
,
112 struct expression
*exp
,
113 enum noside noside
) override
;
115 enum exp_opcode
opcode () const override
116 { return TERNOP_IN_RANGE
; }
119 using ada_neg_operation
= unop_operation
<UNOP_NEG
, ada_unop_neg
>;
120 using ada_atr_tag_operation
= unop_operation
<OP_ATR_TAG
, ada_atr_tag
>;
121 using ada_atr_size_operation
= unop_operation
<OP_ATR_SIZE
, ada_atr_size
>;
122 using ada_abs_operation
= unop_operation
<UNOP_ABS
, ada_abs
>;
124 /* The in-range operation, given a type. */
125 class ada_unop_range_operation
126 : public tuple_holding_operation
<operation_up
, struct type
*>
130 using tuple_holding_operation::tuple_holding_operation
;
132 value
*evaluate (struct type
*expect_type
,
133 struct expression
*exp
,
134 enum noside noside
) override
136 value
*val
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
137 return ada_unop_in_range (expect_type
, exp
, noside
, UNOP_IN_RANGE
,
138 val
, std::get
<1> (m_storage
));
141 enum exp_opcode
opcode () const override
142 { return UNOP_IN_RANGE
; }
145 /* The Ada + and - operators. */
146 class ada_binop_addsub_operation
147 : public tuple_holding_operation
<enum exp_opcode
, operation_up
, operation_up
>
151 using tuple_holding_operation::tuple_holding_operation
;
153 value
*evaluate (struct type
*expect_type
,
154 struct expression
*exp
,
155 enum noside noside
) override
;
157 enum exp_opcode
opcode () const override
158 { return std::get
<0> (m_storage
); }
161 using ada_binop_mul_operation
= binop_operation
<BINOP_MUL
, ada_mult_binop
>;
162 using ada_binop_div_operation
= binop_operation
<BINOP_DIV
, ada_mult_binop
>;
163 using ada_binop_rem_operation
= binop_operation
<BINOP_REM
, ada_mult_binop
>;
164 using ada_binop_mod_operation
= binop_operation
<BINOP_MOD
, ada_mult_binop
>;
166 /* Implement the equal and not-equal operations for Ada. */
167 class ada_binop_equal_operation
168 : public tuple_holding_operation
<enum exp_opcode
, operation_up
, operation_up
>
172 using tuple_holding_operation::tuple_holding_operation
;
174 value
*evaluate (struct type
*expect_type
,
175 struct expression
*exp
,
176 enum noside noside
) override
178 value
*arg1
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
179 value
*arg2
= std::get
<2> (m_storage
)->evaluate (value_type (arg1
),
181 return ada_equal_binop (expect_type
, exp
, noside
, std::get
<0> (m_storage
),
185 enum exp_opcode
opcode () const override
186 { return std::get
<0> (m_storage
); }
189 } /* namespace expr */
191 #endif /* ADA_EXP_H */