]> Git Repo - binutils.git/blob - gdb/ada-exp.h
Automatic date update in version.in
[binutils.git] / gdb / ada-exp.h
1 /* Definitions for Ada expressions
2
3    Copyright (C) 2020-2022 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 #ifndef ADA_EXP_H
21 #define ADA_EXP_H
22
23 #include "expop.h"
24
25 extern struct value *ada_unop_neg (struct type *expect_type,
26                                    struct expression *exp,
27                                    enum noside noside, enum exp_opcode op,
28                                    struct value *arg1);
29 extern struct value *ada_atr_tag (struct type *expect_type,
30                                   struct expression *exp,
31                                   enum noside noside, enum exp_opcode op,
32                                   struct value *arg1);
33 extern struct value *ada_atr_size (struct type *expect_type,
34                                    struct expression *exp,
35                                    enum noside noside, enum exp_opcode op,
36                                    struct value *arg1);
37 extern struct value *ada_abs (struct type *expect_type,
38                               struct expression *exp,
39                               enum noside noside, enum exp_opcode op,
40                               struct value *arg1);
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);
53 extern struct value *ada_ternop_slice (struct expression *exp,
54                                        enum noside noside,
55                                        struct value *array,
56                                        struct value *low_bound_val,
57                                        struct value *high_bound_val);
58 extern struct value *ada_binop_in_bounds (struct expression *exp,
59                                           enum noside noside,
60                                           struct value *arg1,
61                                           struct value *arg2,
62                                           int n);
63 extern struct value *ada_binop_minmax (struct type *expect_type,
64                                        struct expression *exp,
65                                        enum noside noside, enum exp_opcode op,
66                                        struct value *arg1,
67                                        struct value *arg2);
68 extern struct value *ada_pos_atr (struct type *expect_type,
69                                   struct expression *exp,
70                                   enum noside noside, enum exp_opcode op,
71                                   struct value *arg);
72 extern struct value *ada_val_atr (enum noside noside, struct type *type,
73                                   struct value *arg);
74 extern struct value *ada_binop_exp (struct type *expect_type,
75                                     struct expression *exp,
76                                     enum noside noside, enum exp_opcode op,
77                                     struct value *arg1, struct value *arg2);
78
79 namespace expr
80 {
81
82 /* The base class for Ada type resolution.  Ada operations that want
83    to participate in resolution implement this interface.  */
84 struct ada_resolvable
85 {
86   /* Resolve this object.  EXP is the expression being resolved.
87      DEPROCEDURE_P is true if a symbol that refers to a zero-argument
88      function may be turned into a function call.  PARSE_COMPLETION
89      and TRACKER are passed in from the parser context.  CONTEXT_TYPE
90      is the expected type of the expression, or nullptr if none is
91      known.  This method should return true if the operation should be
92      replaced by a function call with this object as the callee.  */
93   virtual bool resolve (struct expression *exp,
94                         bool deprocedure_p,
95                         bool parse_completion,
96                         innermost_block_tracker *tracker,
97                         struct type *context_type) = 0;
98
99   /* Possibly replace this object with some other expression object.
100      This is like 'resolve', but can return a replacement.
101
102      The default implementation calls 'resolve' and wraps this object
103      in a function call if that call returns true.  OWNER is a
104      reference to the unique pointer that owns the 'this'; it can be
105      'move'd from to construct the replacement.
106
107      This should either return a new object, or OWNER -- never
108      nullptr.  */
109
110   virtual operation_up replace (operation_up &&owner,
111                                 struct expression *exp,
112                                 bool deprocedure_p,
113                                 bool parse_completion,
114                                 innermost_block_tracker *tracker,
115                                 struct type *context_type);
116 };
117
118 /* In Ada, some generic operations must be wrapped with a handler that
119    handles some Ada-specific type conversions.  */
120 class ada_wrapped_operation
121   : public tuple_holding_operation<operation_up>
122 {
123 public:
124
125   using tuple_holding_operation::tuple_holding_operation;
126
127   value *evaluate (struct type *expect_type,
128                    struct expression *exp,
129                    enum noside noside) override;
130
131   enum exp_opcode opcode () const override
132   { return std::get<0> (m_storage)->opcode (); }
133 };
134
135 /* An Ada string constant.  */
136 class ada_string_operation
137   : public string_operation
138 {
139 public:
140
141   using string_operation::string_operation;
142
143   /* Return the underlying string.  */
144   const char *get_name () const
145   {
146     return std::get<0> (m_storage).c_str ();
147   }
148
149   value *evaluate (struct type *expect_type,
150                    struct expression *exp,
151                    enum noside noside) override;
152 };
153
154 /* The Ada TYPE'(EXP) construct.  */
155 class ada_qual_operation
156   : public tuple_holding_operation<operation_up, struct type *>
157 {
158 public:
159
160   using tuple_holding_operation::tuple_holding_operation;
161
162   value *evaluate (struct type *expect_type,
163                    struct expression *exp,
164                    enum noside noside) override;
165
166   enum exp_opcode opcode () const override
167   { return UNOP_QUAL; }
168 };
169
170 /* Ternary in-range operator.  */
171 class ada_ternop_range_operation
172   : public tuple_holding_operation<operation_up, operation_up, operation_up>
173 {
174 public:
175
176   using tuple_holding_operation::tuple_holding_operation;
177
178   value *evaluate (struct type *expect_type,
179                    struct expression *exp,
180                    enum noside noside) override;
181
182   enum exp_opcode opcode () const override
183   { return TERNOP_IN_RANGE; }
184 };
185
186 using ada_neg_operation = unop_operation<UNOP_NEG, ada_unop_neg>;
187 using ada_atr_tag_operation = unop_operation<OP_ATR_TAG, ada_atr_tag>;
188 using ada_atr_size_operation = unop_operation<OP_ATR_SIZE, ada_atr_size>;
189 using ada_abs_operation = unop_operation<UNOP_ABS, ada_abs>;
190 using ada_pos_operation = unop_operation<OP_ATR_POS, ada_pos_atr>;
191
192 /* The in-range operation, given a type.  */
193 class ada_unop_range_operation
194   : public tuple_holding_operation<operation_up, struct type *>
195 {
196 public:
197
198   using tuple_holding_operation::tuple_holding_operation;
199
200   value *evaluate (struct type *expect_type,
201                    struct expression *exp,
202                    enum noside noside) override
203   {
204     value *val = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
205     return ada_unop_in_range (expect_type, exp, noside, UNOP_IN_RANGE,
206                               val, std::get<1> (m_storage));
207   }
208
209   enum exp_opcode opcode () const override
210   { return UNOP_IN_RANGE; }
211 };
212
213 /* The Ada + and - operators.  */
214 class ada_binop_addsub_operation
215   : public tuple_holding_operation<enum exp_opcode, operation_up, operation_up>
216 {
217 public:
218
219   using tuple_holding_operation::tuple_holding_operation;
220
221   value *evaluate (struct type *expect_type,
222                    struct expression *exp,
223                    enum noside noside) override;
224
225   enum exp_opcode opcode () const override
226   { return std::get<0> (m_storage); }
227 };
228
229 using ada_binop_mul_operation = binop_operation<BINOP_MUL, ada_mult_binop>;
230 using ada_binop_div_operation = binop_operation<BINOP_DIV, ada_mult_binop>;
231 using ada_binop_rem_operation = binop_operation<BINOP_REM, ada_mult_binop>;
232 using ada_binop_mod_operation = binop_operation<BINOP_MOD, ada_mult_binop>;
233
234 using ada_binop_min_operation = binop_operation<BINOP_MIN, ada_binop_minmax>;
235 using ada_binop_max_operation = binop_operation<BINOP_MAX, ada_binop_minmax>;
236
237 using ada_binop_exp_operation = binop_operation<BINOP_EXP, ada_binop_exp>;
238
239 /* Implement the equal and not-equal operations for Ada.  */
240 class ada_binop_equal_operation
241   : public tuple_holding_operation<enum exp_opcode, operation_up, operation_up>
242 {
243 public:
244
245   using tuple_holding_operation::tuple_holding_operation;
246
247   value *evaluate (struct type *expect_type,
248                    struct expression *exp,
249                    enum noside noside) override
250   {
251     value *arg1 = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
252     value *arg2 = std::get<2> (m_storage)->evaluate (value_type (arg1),
253                                                      exp, noside);
254     return ada_equal_binop (expect_type, exp, noside, std::get<0> (m_storage),
255                             arg1, arg2);
256   }
257
258   enum exp_opcode opcode () const override
259   { return std::get<0> (m_storage); }
260 };
261
262 /* Bitwise operators for Ada.  */
263 template<enum exp_opcode OP>
264 class ada_bitwise_operation
265   : public maybe_constant_operation<operation_up, operation_up>
266 {
267 public:
268
269   using maybe_constant_operation::maybe_constant_operation;
270
271   value *evaluate (struct type *expect_type,
272                    struct expression *exp,
273                    enum noside noside) override
274   {
275     value *lhs = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
276     value *rhs = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
277     value *result = eval_op_binary (expect_type, exp, noside, OP, lhs, rhs);
278     return value_cast (value_type (lhs), result);
279   }
280
281   enum exp_opcode opcode () const override
282   { return OP; }
283 };
284
285 using ada_bitwise_and_operation = ada_bitwise_operation<BINOP_BITWISE_AND>;
286 using ada_bitwise_ior_operation = ada_bitwise_operation<BINOP_BITWISE_IOR>;
287 using ada_bitwise_xor_operation = ada_bitwise_operation<BINOP_BITWISE_XOR>;
288
289 /* Ada array- or string-slice operation.  */
290 class ada_ternop_slice_operation
291   : public maybe_constant_operation<operation_up, operation_up, operation_up>,
292     public ada_resolvable
293 {
294 public:
295
296   using maybe_constant_operation::maybe_constant_operation;
297
298   value *evaluate (struct type *expect_type,
299                    struct expression *exp,
300                    enum noside noside) override
301   {
302     value *array = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
303     value *low = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
304     value *high = std::get<2> (m_storage)->evaluate (nullptr, exp, noside);
305     return ada_ternop_slice (exp, noside, array, low, high);
306   }
307
308   enum exp_opcode opcode () const override
309   { return TERNOP_SLICE; }
310
311   bool resolve (struct expression *exp,
312                 bool deprocedure_p,
313                 bool parse_completion,
314                 innermost_block_tracker *tracker,
315                 struct type *context_type) override;
316 };
317
318 /* Implement BINOP_IN_BOUNDS for Ada.  */
319 class ada_binop_in_bounds_operation
320   : public maybe_constant_operation<operation_up, operation_up, int>
321 {
322 public:
323
324   using maybe_constant_operation::maybe_constant_operation;
325
326   value *evaluate (struct type *expect_type,
327                    struct expression *exp,
328                    enum noside noside) override
329   {
330     value *arg1 = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
331     value *arg2 = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
332     return ada_binop_in_bounds (exp, noside, arg1, arg2,
333                                 std::get<2> (m_storage));
334   }
335
336   enum exp_opcode opcode () const override
337   { return BINOP_IN_BOUNDS; }
338 };
339
340 /* Implement several unary Ada OP_ATR_* operations.  */
341 class ada_unop_atr_operation
342   : public maybe_constant_operation<operation_up, enum exp_opcode, int>
343 {
344 public:
345
346   using maybe_constant_operation::maybe_constant_operation;
347
348   value *evaluate (struct type *expect_type,
349                    struct expression *exp,
350                    enum noside noside) override;
351
352   enum exp_opcode opcode () const override
353   { return std::get<1> (m_storage); }
354 };
355
356 /* Variant of var_value_operation for Ada.  */
357 class ada_var_value_operation
358   : public var_value_operation, public ada_resolvable
359 {
360 public:
361
362   using var_value_operation::var_value_operation;
363
364   value *evaluate (struct type *expect_type,
365                    struct expression *exp,
366                    enum noside noside) override;
367
368   value *evaluate_for_cast (struct type *expect_type,
369                             struct expression *exp,
370                             enum noside noside) override;
371
372   const block *get_block () const
373   { return std::get<0> (m_storage).block; }
374
375   bool resolve (struct expression *exp,
376                 bool deprocedure_p,
377                 bool parse_completion,
378                 innermost_block_tracker *tracker,
379                 struct type *context_type) override;
380
381 protected:
382
383   using operation::do_generate_ax;
384 };
385
386 /* Variant of var_msym_value_operation for Ada.  */
387 class ada_var_msym_value_operation
388   : public var_msym_value_operation
389 {
390 public:
391
392   using var_msym_value_operation::var_msym_value_operation;
393
394   value *evaluate_for_cast (struct type *expect_type,
395                             struct expression *exp,
396                             enum noside noside) override;
397
398 protected:
399
400   using operation::do_generate_ax;
401 };
402
403 /* Implement the Ada 'val attribute.  */
404 class ada_atr_val_operation
405   : public tuple_holding_operation<struct type *, operation_up>
406 {
407 public:
408
409   using tuple_holding_operation::tuple_holding_operation;
410
411   value *evaluate (struct type *expect_type,
412                    struct expression *exp,
413                    enum noside noside) override;
414
415   enum exp_opcode opcode () const override
416   { return OP_ATR_VAL; }
417 };
418
419 /* The indirection operator for Ada.  */
420 class ada_unop_ind_operation
421   : public unop_ind_base_operation
422 {
423 public:
424
425   using unop_ind_base_operation::unop_ind_base_operation;
426
427   value *evaluate (struct type *expect_type,
428                    struct expression *exp,
429                    enum noside noside) override;
430 };
431
432 /* Implement STRUCTOP_STRUCT for Ada.  */
433 class ada_structop_operation
434   : public structop_base_operation
435 {
436 public:
437
438   using structop_base_operation::structop_base_operation;
439
440   value *evaluate (struct type *expect_type,
441                    struct expression *exp,
442                    enum noside noside) override;
443
444   enum exp_opcode opcode () const override
445   { return STRUCTOP_STRUCT; }
446
447   /* Set the completion prefix.  */
448   void set_prefix (std::string &&prefix)
449   {
450     m_prefix = std::move (prefix);
451   }
452
453   bool complete (struct expression *exp, completion_tracker &tracker) override
454   {
455     return structop_base_operation::complete (exp, tracker, m_prefix.c_str ());
456   }
457
458   void dump (struct ui_file *stream, int depth) const override
459   {
460     structop_base_operation::dump (stream, depth);
461     dump_for_expression (stream, depth + 1, m_prefix);
462   }
463
464 private:
465
466   /* We may need to provide a prefix to field name completion.  See
467      ada-exp.y:find_completion_bounds for details.  */
468   std::string m_prefix;
469 };
470
471 /* Function calls for Ada.  */
472 class ada_funcall_operation
473   : public tuple_holding_operation<operation_up, std::vector<operation_up>>,
474     public ada_resolvable
475 {
476 public:
477
478   using tuple_holding_operation::tuple_holding_operation;
479
480   value *evaluate (struct type *expect_type,
481                    struct expression *exp,
482                    enum noside noside) override;
483
484   bool resolve (struct expression *exp,
485                 bool deprocedure_p,
486                 bool parse_completion,
487                 innermost_block_tracker *tracker,
488                 struct type *context_type) override;
489
490   enum exp_opcode opcode () const override
491   { return OP_FUNCALL; }
492 };
493
494 /* An Ada assignment operation.  */
495 class ada_assign_operation
496   : public assign_operation
497 {
498 public:
499
500   using assign_operation::assign_operation;
501
502   value *evaluate (struct type *expect_type,
503                    struct expression *exp,
504                    enum noside noside) override;
505
506   enum exp_opcode opcode () const override
507   { return BINOP_ASSIGN; }
508 };
509
510 /* This abstract class represents a single component in an Ada
511    aggregate assignment.  */
512 class ada_component
513 {
514 public:
515
516   /* Assign to LHS, which is part of CONTAINER.  EXP is the expression
517      being evaluated.  INDICES, LOW, and HIGH indicate which
518      sub-components have already been assigned; INDICES should be
519      updated by this call.  */
520   virtual void assign (struct value *container,
521                        struct value *lhs, struct expression *exp,
522                        std::vector<LONGEST> &indices,
523                        LONGEST low, LONGEST high) = 0;
524
525   /* Same as operation::uses_objfile.  */
526   virtual bool uses_objfile (struct objfile *objfile) = 0;
527
528   /* Same as operation::dump.  */
529   virtual void dump (ui_file *stream, int depth) = 0;
530
531   virtual ~ada_component () = default;
532
533 protected:
534
535   ada_component () = default;
536   DISABLE_COPY_AND_ASSIGN (ada_component);
537 };
538
539 /* Unique pointer specialization for Ada assignment components.  */
540 typedef std::unique_ptr<ada_component> ada_component_up;
541
542 /* An operation that holds a single component.  */
543 class ada_aggregate_operation
544   : public tuple_holding_operation<ada_component_up>
545 {
546 public:
547
548   using tuple_holding_operation::tuple_holding_operation;
549
550   /* Assuming that LHS represents an lvalue having a record or array
551      type, evaluate an assignment of this aggregate's value to LHS.
552      CONTAINER is an lvalue containing LHS (possibly LHS itself).
553      Does not modify the inferior's memory, nor does it modify the
554      contents of LHS (unless == CONTAINER).  Returns the modified
555      CONTAINER.  */
556
557   value *assign_aggregate (struct value *container,
558                            struct value *lhs,
559                            struct expression *exp);
560
561   value *evaluate (struct type *expect_type,
562                    struct expression *exp,
563                    enum noside noside) override
564   {
565     error (_("Aggregates only allowed on the right of an assignment"));
566   }
567
568   enum exp_opcode opcode () const override
569   { return OP_AGGREGATE; }
570 };
571
572 /* A component holding a vector of other components to assign.  */
573 class ada_aggregate_component : public ada_component
574 {
575 public:
576
577   explicit ada_aggregate_component (std::vector<ada_component_up> &&components)
578     : m_components (std::move (components))
579   {
580   }
581
582   void assign (struct value *container,
583                struct value *lhs, struct expression *exp,
584                std::vector<LONGEST> &indices,
585                LONGEST low, LONGEST high) override;
586
587   bool uses_objfile (struct objfile *objfile) override;
588
589   void dump (ui_file *stream, int depth) override;
590
591 private:
592
593   std::vector<ada_component_up> m_components;
594 };
595
596 /* A component that assigns according to a provided index (which is
597    relative to the "low" value).  */
598 class ada_positional_component : public ada_component
599 {
600 public:
601
602   ada_positional_component (int index, operation_up &&op)
603     : m_index (index),
604       m_op (std::move (op))
605   {
606   }
607
608   void assign (struct value *container,
609                struct value *lhs, struct expression *exp,
610                std::vector<LONGEST> &indices,
611                LONGEST low, LONGEST high) override;
612
613   bool uses_objfile (struct objfile *objfile) override;
614
615   void dump (ui_file *stream, int depth) override;
616
617 private:
618
619   int m_index;
620   operation_up m_op;
621 };
622
623 /* A component which handles an "others" clause.  */
624 class ada_others_component : public ada_component
625 {
626 public:
627
628   explicit ada_others_component (operation_up &&op)
629     : m_op (std::move (op))
630   {
631   }
632
633   void assign (struct value *container,
634                struct value *lhs, struct expression *exp,
635                std::vector<LONGEST> &indices,
636                LONGEST low, LONGEST high) override;
637
638   bool uses_objfile (struct objfile *objfile) override;
639
640   void dump (ui_file *stream, int depth) override;
641
642 private:
643
644   operation_up m_op;
645 };
646
647 /* An interface that represents an association that is used in
648    aggregate assignment.  */
649 class ada_association
650 {
651 public:
652
653   /* Like ada_component::assign, but takes an operation as a
654      parameter.  The operation is evaluated and then assigned into LHS
655      according to the rules of the concrete implementation.  */
656   virtual void assign (struct value *container,
657                        struct value *lhs,
658                        struct expression *exp,
659                        std::vector<LONGEST> &indices,
660                        LONGEST low, LONGEST high,
661                        operation_up &op) = 0;
662
663   /* Same as operation::uses_objfile.  */
664   virtual bool uses_objfile (struct objfile *objfile) = 0;
665
666   /* Same as operation::dump.  */
667   virtual void dump (ui_file *stream, int depth) = 0;
668
669   virtual ~ada_association () = default;
670
671 protected:
672
673   ada_association () = default;
674   DISABLE_COPY_AND_ASSIGN (ada_association);
675 };
676
677 /* Unique pointer specialization for Ada assignment associations.  */
678 typedef std::unique_ptr<ada_association> ada_association_up;
679
680 /* A component that holds a vector of associations and an operation.
681    The operation is re-evaluated for each choice.  */
682 class ada_choices_component : public ada_component
683 {
684 public:
685
686   explicit ada_choices_component (operation_up &&op)
687     : m_op (std::move (op))
688   {
689   }
690
691   /* Set the vector of associations.  This is done separately from the
692      constructor because it was simpler for the implementation of the
693      parser.  */
694   void set_associations (std::vector<ada_association_up> &&assoc)
695   {
696     m_assocs = std::move (assoc);
697   }
698
699   void assign (struct value *container,
700                struct value *lhs, struct expression *exp,
701                std::vector<LONGEST> &indices,
702                LONGEST low, LONGEST high) override;
703
704   bool uses_objfile (struct objfile *objfile) override;
705
706   void dump (ui_file *stream, int depth) override;
707
708 private:
709
710   std::vector<ada_association_up> m_assocs;
711   operation_up m_op;
712 };
713
714 /* An association that uses a discrete range.  */
715 class ada_discrete_range_association : public ada_association
716 {
717 public:
718
719   ada_discrete_range_association (operation_up &&low, operation_up &&high)
720     : m_low (std::move (low)),
721       m_high (std::move (high))
722   {
723   }
724
725   void assign (struct value *container,
726                struct value *lhs, struct expression *exp,
727                std::vector<LONGEST> &indices,
728                LONGEST low, LONGEST high,
729                operation_up &op) override;
730
731   bool uses_objfile (struct objfile *objfile) override;
732
733   void dump (ui_file *stream, int depth) override;
734
735 private:
736
737   operation_up m_low;
738   operation_up m_high;
739 };
740
741 /* An association that uses a name.  The name may be an expression
742    that evaluates to an integer (for arrays), or an Ada string or
743    variable value operation.  */
744 class ada_name_association : public ada_association
745 {
746 public:
747
748   explicit ada_name_association (operation_up val)
749     : m_val (std::move (val))
750   {
751   }
752
753   void assign (struct value *container,
754                struct value *lhs, struct expression *exp,
755                std::vector<LONGEST> &indices,
756                LONGEST low, LONGEST high,
757                operation_up &op) override;
758
759   bool uses_objfile (struct objfile *objfile) override;
760
761   void dump (ui_file *stream, int depth) override;
762
763 private:
764
765   operation_up m_val;
766 };
767
768 /* A character constant expression.  This is a separate operation so
769    that it can participate in resolution, so that TYPE'(CST) can
770    work correctly for enums with character enumerators.  */
771 class ada_char_operation : public long_const_operation,
772                            public ada_resolvable
773 {
774 public:
775
776   using long_const_operation::long_const_operation;
777
778   bool resolve (struct expression *exp,
779                 bool deprocedure_p,
780                 bool parse_completion,
781                 innermost_block_tracker *tracker,
782                 struct type *context_type) override
783   {
784     /* This should never be called, because this class also implements
785        'replace'.  */
786     gdb_assert_not_reached ("unexpected call");
787   }
788
789   operation_up replace (operation_up &&owner,
790                         struct expression *exp,
791                         bool deprocedure_p,
792                         bool parse_completion,
793                         innermost_block_tracker *tracker,
794                         struct type *context_type) override;
795
796   value *evaluate (struct type *expect_type,
797                    struct expression *exp,
798                    enum noside noside) override;
799 };
800
801 class ada_concat_operation : public concat_operation
802 {
803 public:
804
805   using concat_operation::concat_operation;
806
807   value *evaluate (struct type *expect_type,
808                    struct expression *exp,
809                    enum noside noside) override;
810 };
811
812 } /* namespace expr */
813
814 #endif /* ADA_EXP_H */
This page took 0.072952 seconds and 4 git commands to generate.