source: src/SynTree/Expression.h @ 8e9cbb2

ADTaaron-thesisarm-ehast-experimentalcleanup-dtorsctordeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxmemorynew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newwith_gc
Last change on this file since 8e9cbb2 was 8e9cbb2, checked in by Peter A. Buhr <pabuhr@…>, 8 years ago

add more code to handle gcc extension and test program, second attempt

  • Property mode set to 100644
File size: 24.3 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// Expression.h --
8//
9// Author           : Richard C. Bilson
10// Created On       : Mon May 18 07:44:20 2015
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Mon Jul  4 14:45:32 2016
13// Update Count     : 23
14//
15
16#ifndef EXPRESSION_H
17#define EXPRESSION_H
18
19#include <map>
20#include "SynTree.h"
21#include "Visitor.h"
22#include "Mutator.h"
23#include "Constant.h"
24#include "Common/UniqueName.h"
25
26/// Expression is the root type for all expressions
27class Expression {
28  public:
29        Expression(Expression *_aname = 0 );
30        Expression( const Expression &other );
31        virtual ~Expression();
32
33        std::list<Type *>& get_results() { return results; }
34        void add_result( Type *t );
35
36        TypeSubstitution *get_env() const { return env; }
37        void set_env( TypeSubstitution *newValue ) { env = newValue; }
38        Expression *get_argName() const { return argName; }
39        void set_argName( Expression *name ) { argName = name; }
40        bool get_extension() const { return extension; }
41        Expression * set_extension( bool exten ) { extension = exten; return this; }
42
43        virtual Expression *clone() const = 0;
44        virtual void accept( Visitor &v ) = 0;
45        virtual Expression *acceptMutator( Mutator &m ) = 0;
46        virtual void print( std::ostream &os, int indent = 0 ) const;
47  protected:
48        std::list<Type *> results;
49        TypeSubstitution *env;
50        Expression* argName; // if expression is used as an argument, it can be "designated" by this name
51        bool extension = false;
52};
53
54/// ParamEntry contains the i.d. of a declaration and a type that is derived from that declaration,
55/// but subject to decay-to-pointer and type parameter renaming
56struct ParamEntry {
57        ParamEntry(): decl( 0 ), actualType( 0 ), formalType( 0 ), expr( 0 ) {}
58        ParamEntry( UniqueId decl, Type *actualType, Type *formalType, Expression* expr ): decl( decl ), actualType( actualType ), formalType( formalType ), expr( expr ) {}
59        ParamEntry( const ParamEntry &other );
60        ~ParamEntry();
61        ParamEntry &operator=( const ParamEntry &other );
62
63        UniqueId decl;
64        Type *actualType;
65        Type *formalType;
66        Expression* expr;
67};
68
69typedef std::map< UniqueId, ParamEntry > InferredParams;
70
71/// ApplicationExpr represents the application of a function to a set of parameters.  This is the
72/// result of running an UntypedExpr through the expression analyzer.
73class ApplicationExpr : public Expression {
74  public:
75        ApplicationExpr( Expression *function );
76        ApplicationExpr( const ApplicationExpr &other );
77        virtual ~ApplicationExpr();
78
79        Expression *get_function() const { return function; }
80        void set_function( Expression *newValue ) { function = newValue; }
81        std::list<Expression *>& get_args() { return args; }
82        InferredParams &get_inferParams() { return inferParams; }
83
84        virtual ApplicationExpr *clone() const { return new ApplicationExpr( *this ); }
85        virtual void accept( Visitor &v ) { v.visit( this ); }
86        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
87        virtual void print( std::ostream &os, int indent = 0 ) const;
88  private:
89        Expression *function;
90        std::list<Expression *> args;
91        InferredParams inferParams;
92};
93
94/// UntypedExpr represents the application of a function to a set of parameters, but where the
95/// particular overload for the function name has not yet been determined.  Most operators are
96/// converted into functional form automatically, to permit operator overloading.
97class UntypedExpr : public Expression {
98  public:
99        UntypedExpr( Expression *function, Expression *_aname = 0 );
100        UntypedExpr( const UntypedExpr &other );
101        UntypedExpr( Expression *function, std::list<Expression *> &args, Expression *_aname = 0 );
102        virtual ~UntypedExpr();
103
104        Expression *get_function() const { return function; }
105        void set_function( Expression *newValue ) { function = newValue; }
106
107        void set_args( std::list<Expression *> &listArgs ) { args = listArgs; }
108        std::list<Expression*>::iterator begin_args() { return args.begin(); }
109        std::list<Expression*>::iterator end_args() { return args.end(); }
110        std::list<Expression*>& get_args() { return args; }
111
112        virtual UntypedExpr *clone() const { return new UntypedExpr( *this ); }
113        virtual void accept( Visitor &v ) { v.visit( this ); }
114        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
115        virtual void print( std::ostream &os, int indent = 0 ) const;
116        virtual void printArgs(std::ostream &os, int indent = 0) const;
117  private:
118        Expression *function;
119        std::list<Expression*> args;
120};
121
122/// NameExpr contains a name whose meaning is still not determined
123class NameExpr : public Expression {
124  public:
125        NameExpr( std::string name, Expression *_aname = 0 );
126        NameExpr( const NameExpr &other );
127        virtual ~NameExpr();
128
129        const std::string &get_name() const { return name; }
130        void set_name( std::string newValue ) { name = newValue; }
131
132        virtual NameExpr *clone() const { return new NameExpr( *this ); }
133        virtual void accept( Visitor &v ) { v.visit( this ); }
134        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
135        virtual void print( std::ostream &os, int indent = 0 ) const;
136  private:
137        std::string name;
138};
139
140// The following classes are used to represent expression types that cannot be converted into
141// function-call format.
142
143/// AddressExpr represents a address-of expression, e.g. &e
144class AddressExpr : public Expression {
145  public:
146        AddressExpr( Expression *arg, Expression *_aname = 0 );
147        AddressExpr( const AddressExpr &other );
148        virtual ~AddressExpr();
149
150        Expression *get_arg() const { return arg; }
151        void set_arg(Expression *newValue ) { arg = newValue; }
152
153        virtual AddressExpr *clone() const { return new AddressExpr( *this ); }
154        virtual void accept( Visitor &v ) { v.visit( this ); }
155        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
156        virtual void print( std::ostream &os, int indent = 0 ) const;
157  private:
158        Expression *arg;
159};
160
161// xxx - this doesn't appear to actually be hooked in anywhere. We should use this instead of the "&&"" UntypedExpr hack
162class LabelAddressExpr : public Expression {
163  public:
164        LabelAddressExpr( Expression *arg );
165        LabelAddressExpr( const LabelAddressExpr &other );
166        virtual ~LabelAddressExpr();
167
168        Expression *get_arg() const { return arg; }
169        void set_arg(Expression *newValue ) { arg = newValue; }
170
171        virtual LabelAddressExpr *clone() const { return new LabelAddressExpr( *this ); }
172        virtual void accept( Visitor &v ) { v.visit( this ); }
173        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
174        virtual void print( std::ostream &os, int indent = 0 ) const;
175  private:
176        Expression *arg;
177};
178
179/// CastExpr represents a type cast expression, e.g. (int)e
180class CastExpr : public Expression {
181  public:
182        CastExpr( Expression *arg, Expression *_aname = 0 );
183        CastExpr( Expression *arg, Type *toType, Expression *_aname = 0 );
184        CastExpr( const CastExpr &other );
185        virtual ~CastExpr();
186
187        Expression *get_arg() const { return arg; }
188        void set_arg(Expression *newValue ) { arg = newValue; }
189
190        virtual CastExpr *clone() const { return new CastExpr( *this ); }
191        virtual void accept( Visitor &v ) { v.visit( this ); }
192        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
193        virtual void print( std::ostream &os, int indent = 0 ) const;
194  private:
195        Expression *arg;
196};
197
198/// UntypedMemberExpr represents a member selection operation, e.g. q.p before processing by the expression analyzer
199class UntypedMemberExpr : public Expression {
200  public:
201        UntypedMemberExpr( std::string member, Expression *aggregate, Expression *_aname = 0 );
202        UntypedMemberExpr( const UntypedMemberExpr &other );
203        virtual ~UntypedMemberExpr();
204
205        std::string get_member() const { return member; }
206        void set_member( const std::string &newValue ) { member = newValue; }
207        Expression *get_aggregate() const { return aggregate; }
208        void set_aggregate( Expression *newValue ) { aggregate = newValue; }
209
210        virtual UntypedMemberExpr *clone() const { return new UntypedMemberExpr( *this ); }
211        virtual void accept( Visitor &v ) { v.visit( this ); }
212        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
213        virtual void print( std::ostream &os, int indent = 0 ) const;
214  private:
215        std::string member;
216        Expression *aggregate;
217};
218
219/// MemberExpr represents a member selection operation, e.g. q.p after processing by the expression analyzer
220class MemberExpr : public Expression {
221  public:
222        MemberExpr( DeclarationWithType *member, Expression *aggregate, Expression *_aname = 0 );
223        MemberExpr( const MemberExpr &other );
224        virtual ~MemberExpr();
225
226        DeclarationWithType *get_member() const { return member; }
227        void set_member( DeclarationWithType *newValue ) { member = newValue; }
228        Expression *get_aggregate() const { return aggregate; }
229        void set_aggregate( Expression *newValue ) { aggregate = newValue; }
230
231        virtual MemberExpr *clone() const { return new MemberExpr( *this ); }
232        virtual void accept( Visitor &v ) { v.visit( this ); }
233        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
234        virtual void print( std::ostream &os, int indent = 0 ) const;
235  private:
236        DeclarationWithType *member;
237        Expression *aggregate;
238};
239
240/// VariableExpr represents an expression that simply refers to the value of a named variable
241class VariableExpr : public Expression {
242  public:
243        VariableExpr( DeclarationWithType *var, Expression *_aname = 0 );
244        VariableExpr( const VariableExpr &other );
245        virtual ~VariableExpr();
246
247        DeclarationWithType *get_var() const { return var; }
248        void set_var( DeclarationWithType *newValue ) { var = newValue; }
249
250        virtual VariableExpr *clone() const { return new VariableExpr( *this ); }
251        virtual void accept( Visitor &v ) { v.visit( this ); }
252        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
253        virtual void print( std::ostream &os, int indent = 0 ) const;
254  private:
255        DeclarationWithType *var;
256};
257
258/// ConstantExpr represents an expression that simply refers to the value of a constant
259class ConstantExpr : public Expression {
260  public:
261        ConstantExpr( Constant constant, Expression *_aname = 0 );
262        ConstantExpr( const ConstantExpr &other );
263        virtual ~ConstantExpr();
264
265        Constant *get_constant() { return &constant; }
266        void set_constant( const Constant &newValue ) { constant = newValue; }
267
268        virtual ConstantExpr *clone() const { return new ConstantExpr( *this ); }
269        virtual void accept( Visitor &v ) { v.visit( this ); }
270        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
271        virtual void print( std::ostream &os, int indent = 0 ) const;
272  private:
273        Constant constant;
274};
275
276/// SizeofExpr represents a sizeof expression (could be sizeof(int) or sizeof 3+4)
277class SizeofExpr : public Expression {
278  public:
279        SizeofExpr( Expression *expr, Expression *_aname = 0 );
280        SizeofExpr( const SizeofExpr &other );
281        SizeofExpr( Type *type, Expression *_aname = 0 );
282        virtual ~SizeofExpr();
283
284        Expression *get_expr() const { return expr; }
285        void set_expr( Expression *newValue ) { expr = newValue; }
286        Type *get_type() const { return type; }
287        void set_type( Type *newValue ) { type = newValue; }
288        bool get_isType() const { return isType; }
289        void set_isType( bool newValue ) { isType = newValue; }
290
291        virtual SizeofExpr *clone() const { return new SizeofExpr( *this ); }
292        virtual void accept( Visitor &v ) { v.visit( this ); }
293        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
294        virtual void print( std::ostream &os, int indent = 0 ) const;
295  private:
296        Expression *expr;
297        Type *type;
298        bool isType;
299};
300
301/// AlignofExpr represents an alignof expression
302class AlignofExpr : public Expression {
303  public:
304        AlignofExpr( Expression *expr, Expression *_aname = 0 );
305        AlignofExpr( const AlignofExpr &other );
306        AlignofExpr( Type *type, Expression *_aname = 0 );
307        virtual ~AlignofExpr();
308
309        Expression *get_expr() const { return expr; }
310        void set_expr( Expression *newValue ) { expr = newValue; }
311        Type *get_type() const { return type; }
312        void set_type( Type *newValue ) { type = newValue; }
313        bool get_isType() const { return isType; }
314        void set_isType( bool newValue ) { isType = newValue; }
315
316        virtual AlignofExpr *clone() const { return new AlignofExpr( *this ); }
317        virtual void accept( Visitor &v ) { v.visit( this ); }
318        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
319        virtual void print( std::ostream &os, int indent = 0 ) const;
320  private:
321        Expression *expr;
322        Type *type;
323        bool isType;
324};
325
326/// UntypedOffsetofExpr represents an offsetof expression before resolution
327class UntypedOffsetofExpr : public Expression {
328  public:
329        UntypedOffsetofExpr( Type *type, const std::string &member, Expression *_aname = 0 );
330        UntypedOffsetofExpr( const UntypedOffsetofExpr &other );
331        virtual ~UntypedOffsetofExpr();
332
333        std::string get_member() const { return member; }
334        void set_member( const std::string &newValue ) { member = newValue; }
335        Type *get_type() const { return type; }
336        void set_type( Type *newValue ) { type = newValue; }
337
338        virtual UntypedOffsetofExpr *clone() const { return new UntypedOffsetofExpr( *this ); }
339        virtual void accept( Visitor &v ) { v.visit( this ); }
340        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
341        virtual void print( std::ostream &os, int indent = 0 ) const;
342  private:
343        Type *type;
344        std::string member;
345};
346
347/// OffsetofExpr represents an offsetof expression
348class OffsetofExpr : public Expression {
349  public:
350        OffsetofExpr( Type *type, DeclarationWithType *member, Expression *_aname = 0 );
351        OffsetofExpr( const OffsetofExpr &other );
352        virtual ~OffsetofExpr();
353
354        Type *get_type() const { return type; }
355        void set_type( Type *newValue ) { type = newValue; }
356        DeclarationWithType *get_member() const { return member; }
357        void set_member( DeclarationWithType *newValue ) { member = newValue; }
358
359        virtual OffsetofExpr *clone() const { return new OffsetofExpr( *this ); }
360        virtual void accept( Visitor &v ) { v.visit( this ); }
361        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
362        virtual void print( std::ostream &os, int indent = 0 ) const;
363  private:
364        Type *type;
365        DeclarationWithType *member;
366};
367
368/// Expression representing a pack of field-offsets for a generic type
369class OffsetPackExpr : public Expression {
370public:
371        OffsetPackExpr( StructInstType *type_, Expression *aname_ = 0 );
372        OffsetPackExpr( const OffsetPackExpr &other );
373        virtual ~OffsetPackExpr();
374
375        StructInstType *get_type() const { return type; }
376        void set_type( StructInstType *newValue ) { type = newValue; }
377
378        virtual OffsetPackExpr *clone() const { return new OffsetPackExpr( *this ); }
379        virtual void accept( Visitor &v ) { v.visit( this ); }
380        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
381
382        virtual void print( std::ostream &os, int indent = 0 ) const;
383
384private:
385        StructInstType *type;
386};
387
388/// AttrExpr represents an @attribute expression (like sizeof, but user-defined)
389class AttrExpr : public Expression {
390  public:
391        AttrExpr(Expression *attr, Expression *expr, Expression *_aname = 0 );
392        AttrExpr( const AttrExpr &other );
393        AttrExpr( Expression *attr, Type *type, Expression *_aname = 0 );
394        virtual ~AttrExpr();
395
396        Expression *get_attr() const { return attr; }
397        void set_attr( Expression *newValue ) { attr = newValue; }
398        Expression *get_expr() const { return expr; }
399        void set_expr( Expression *newValue ) { expr = newValue; }
400        Type *get_type() const { return type; }
401        void set_type( Type *newValue ) { type = newValue; }
402        bool get_isType() const { return isType; }
403        void set_isType( bool newValue ) { isType = newValue; }
404
405        virtual AttrExpr *clone() const { return new AttrExpr( *this ); }
406        virtual void accept( Visitor &v ) { v.visit( this ); }
407        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
408        virtual void print( std::ostream &os, int indent = 0 ) const;
409  private:
410        Expression *attr;
411        Expression *expr;
412        Type *type;
413        bool isType;
414};
415
416/// LogicalExpr represents a short-circuit boolean expression (&& or ||)
417class LogicalExpr : public Expression {
418  public:
419        LogicalExpr( Expression *arg1, Expression *arg2, bool andp = true, Expression *_aname = 0 );
420        LogicalExpr( const LogicalExpr &other );
421        virtual ~LogicalExpr();
422
423        bool get_isAnd() const { return isAnd; }
424        Expression *get_arg1() { return arg1; }
425        void set_arg1( Expression *newValue ) { arg1 = newValue; }
426        Expression *get_arg2() const { return arg2; }
427        void set_arg2( Expression *newValue ) { arg2 = newValue; }
428
429        virtual LogicalExpr *clone() const { return new LogicalExpr( *this ); }
430        virtual void accept( Visitor &v ) { v.visit( this ); }
431        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
432        virtual void print( std::ostream &os, int indent = 0 ) const;
433  private:
434        Expression *arg1;
435        Expression *arg2;
436        bool isAnd;
437};
438
439/// ConditionalExpr represents the three-argument conditional ( p ? a : b )
440class ConditionalExpr : public Expression {
441  public:
442        ConditionalExpr( Expression *arg1, Expression *arg2, Expression *arg3, Expression *_aname = 0 );
443        ConditionalExpr( const ConditionalExpr &other );
444        virtual ~ConditionalExpr();
445
446        Expression *get_arg1() const { return arg1; }
447        void set_arg1( Expression *newValue ) { arg1 = newValue; }
448        Expression *get_arg2() const { return arg2; }
449        void set_arg2( Expression *newValue ) { arg2 = newValue; }
450        Expression *get_arg3() const { return arg3; }
451        void set_arg3( Expression *newValue ) { arg3 = newValue; }
452
453        virtual ConditionalExpr *clone() const { return new ConditionalExpr( *this ); }
454        virtual void accept( Visitor &v ) { v.visit( this ); }
455        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
456        virtual void print( std::ostream &os, int indent = 0 ) const;
457  private:
458        Expression *arg1;
459        Expression *arg2;
460        Expression *arg3;
461};
462
463/// CommaExpr represents the sequence operator ( a, b )
464class CommaExpr : public Expression {
465  public:
466        CommaExpr( Expression *arg1, Expression *arg2, Expression *_aname = 0 );
467        CommaExpr( const CommaExpr &other );
468        virtual ~CommaExpr();
469
470        Expression *get_arg1() const { return arg1; }
471        void set_arg1( Expression *newValue ) { arg1 = newValue; }
472        Expression *get_arg2() const { return arg2; }
473        void set_arg2( Expression *newValue ) { arg2 = newValue; }
474
475        virtual CommaExpr *clone() const { return new CommaExpr( *this ); }
476        virtual void accept( Visitor &v ) { v.visit( this ); }
477        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
478        virtual void print( std::ostream &os, int indent = 0 ) const;
479  private:
480        Expression *arg1;
481        Expression *arg2;
482};
483
484/// TupleExpr represents a tuple expression ( [a, b, c] )
485class TupleExpr : public Expression {
486  public:
487        TupleExpr( Expression *_aname = 0 );
488        TupleExpr( const TupleExpr &other );
489        virtual ~TupleExpr();
490
491        void set_exprs( std::list<Expression*> newValue ) { exprs = newValue; }
492        std::list<Expression*>& get_exprs() { return exprs; }
493
494        virtual TupleExpr *clone() const { return new TupleExpr( *this ); }
495        virtual void accept( Visitor &v ) { v.visit( this ); }
496        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
497        virtual void print( std::ostream &os, int indent = 0 ) const;
498  private:
499        std::list<Expression*> exprs;
500};
501
502/// SolvedTupleExpr represents a TupleExpr whose components have been type-resolved. It is effectively a shell for the code generator to work on
503class SolvedTupleExpr : public Expression {
504  public:
505        SolvedTupleExpr( Expression *_aname = 0 ) : Expression( _aname ) {}
506        SolvedTupleExpr( std::list<Expression *> &, Expression *_aname = 0 );
507        SolvedTupleExpr( const SolvedTupleExpr &other );
508        virtual ~SolvedTupleExpr() {}
509
510        std::list<Expression*> &get_exprs() { return exprs; }
511
512        virtual SolvedTupleExpr *clone() const { return new SolvedTupleExpr( *this ); }
513        virtual void accept( Visitor &v ) { v.visit( this ); }
514        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
515        virtual void print( std::ostream &os, int indent = 0 ) const;
516  private:
517        std::list<Expression*> exprs;
518};
519
520/// TypeExpr represents a type used in an expression (e.g. as a type generator parameter)
521class TypeExpr : public Expression {
522  public:
523        TypeExpr( Type *type );
524        TypeExpr( const TypeExpr &other );
525        virtual ~TypeExpr();
526
527        Type *get_type() const { return type; }
528        void set_type( Type *newValue ) { type = newValue; }
529
530        virtual TypeExpr *clone() const { return new TypeExpr( *this ); }
531        virtual void accept( Visitor &v ) { v.visit( this ); }
532        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
533        virtual void print( std::ostream &os, int indent = 0 ) const;
534  private:
535        Type *type;
536};
537
538/// AsmExpr represents a GCC 'asm constraint operand' used in an asm statement: [output] "=f" (result)
539class AsmExpr : public Expression {
540  public:
541        AsmExpr( Expression *inout, ConstantExpr *constraint, Expression *operand ) : inout( inout ), constraint( constraint ), operand( operand ) {}
542        AsmExpr( const AsmExpr & other );
543        virtual ~AsmExpr() { delete inout; delete constraint; delete operand; };
544
545        Expression *get_inout() const { return inout; }
546        void set_inout( Expression *newValue ) { inout = newValue; }
547
548        ConstantExpr *get_constraint() const { return constraint; }
549        void set_constraint( ConstantExpr *newValue ) { constraint = newValue; }
550
551        Expression *get_operand() const { return operand; }
552        void set_operand( Expression *newValue ) { operand = newValue; }
553
554        virtual AsmExpr *clone() const { return new AsmExpr( *this ); }
555        virtual void accept( Visitor &v ) { v.visit( this ); }
556        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
557        virtual void print( std::ostream &os, int indent = 0 ) const;
558  private:
559        // https://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Machine-Constraints.html#Machine-Constraints
560        Expression *inout;
561        ConstantExpr *constraint;
562        Expression *operand;
563};
564
565/// ImplicitCopyCtorExpr represents the application of a function to a set of parameters,
566/// along with a set of copy constructor calls, one for each argument.
567class ImplicitCopyCtorExpr : public Expression {
568public:
569        ImplicitCopyCtorExpr( ApplicationExpr * callExpr );
570        ImplicitCopyCtorExpr( const ImplicitCopyCtorExpr & other );
571        virtual ~ImplicitCopyCtorExpr();
572
573        ApplicationExpr *get_callExpr() const { return callExpr; }
574        void set_callExpr( ApplicationExpr *newValue ) { callExpr = newValue; }
575
576        std::list< ObjectDecl * > & get_tempDecls() { return tempDecls; }
577        void set_tempDecls( std::list< ObjectDecl * > newValue ) { tempDecls = newValue; }
578
579        std::list< ObjectDecl * > & get_returnDecls() { return returnDecls; }
580        void set_returnDecls( std::list< ObjectDecl * > newValue ) { returnDecls = newValue; }
581
582        std::list< Expression * > & get_dtors() { return dtors; }
583        void set_dtors( std::list< Expression * > newValue ) { dtors = newValue; }
584
585        virtual ImplicitCopyCtorExpr *clone() const { return new ImplicitCopyCtorExpr( *this ); }
586        virtual void accept( Visitor &v ) { v.visit( this ); }
587        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
588        virtual void print( std::ostream &os, int indent = 0 ) const;
589  private:
590        ApplicationExpr * callExpr;
591        std::list< ObjectDecl * > tempDecls;
592        std::list< ObjectDecl * > returnDecls;
593        std::list< Expression * > dtors;
594};
595
596/// ValofExpr represents a GCC 'lambda expression'
597class UntypedValofExpr : public Expression {
598  public:
599        UntypedValofExpr( Statement *_body, Expression *_aname = 0 ) : Expression( _aname ), body ( _body ) {}
600        UntypedValofExpr( const UntypedValofExpr & other );
601        virtual ~UntypedValofExpr();
602
603        Expression *get_value();
604        Statement *get_body() const { return body; }
605
606        virtual UntypedValofExpr *clone() const { return new UntypedValofExpr( *this ); }
607        virtual void accept( Visitor &v ) { v.visit( this ); }
608        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
609        virtual void print( std::ostream &os, int indent = 0 ) const;
610  private:
611        Statement *body;
612};
613
614/// CompoundLiteralExpr represents a C99 'compound literal'
615class CompoundLiteralExpr : public Expression {
616  public:
617        CompoundLiteralExpr( Type * type, Initializer * initializer );
618        CompoundLiteralExpr( const CompoundLiteralExpr &other );
619        ~CompoundLiteralExpr();
620
621        Type * get_type() const { return type; }
622        void set_type( Type * t ) { type = t; }
623
624        Initializer * get_initializer() const { return initializer; }
625        void set_initializer( Initializer * i ) { initializer = i; }
626
627        virtual CompoundLiteralExpr *clone() const { return new CompoundLiteralExpr( *this ); }
628        virtual void accept( Visitor &v ) { v.visit( this ); }
629        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
630        virtual void print( std::ostream &os, int indent = 0 ) const;
631  private:
632        Type * type;
633        Initializer * initializer;
634};
635
636std::ostream & operator<<( std::ostream & out, Expression * expr );
637
638#endif // EXPRESSION_H
639
640// Local Variables: //
641// tab-width: 4 //
642// mode: c++ //
643// compile-command: "make install" //
644// End: //
Note: See TracBrowser for help on using the repository browser.