Changes in src/SynTree/Expression.h [8688ce1:7f5566b]

File:

• src/SynTree/Expression.h (modified) (25 diffs)

src/SynTree/Expression.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Expression.h --
+// Expression.h -- 
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Aug  3 17:08:44 2016
-// Update Count     : 27
+// Last Modified On : Fri Jul 24 13:49:28 2015
+// Update Count     : 18
 //
 
@@ -18 +18 @@
 
 #include <map>
-#include <memory>
 #include "SynTree.h"
 #include "Visitor.h"
 #include "Mutator.h"
 #include "Constant.h"
-#include "Common/UniqueName.h"
-
-/// Expression is the root type for all expressions
+
 class Expression {
   public:
@@ -39 +36 @@
         Expression *get_argName() const { return argName; }
         void set_argName( Expression *name ) { argName = name; }
-        bool get_extension() const { return extension; }
-        Expression * set_extension( bool exten ) { extension = exten; return this; }
 
         virtual Expression *clone() const = 0;
@@ -50 +45 @@
         TypeSubstitution *env;
         Expression* argName; // if expression is used as an argument, it can be "designated" by this name
-        bool extension = false;
-};
-
-/// ParamEntry contains the i.d. of a declaration and a type that is derived from that declaration,
-/// but subject to decay-to-pointer and type parameter renaming
+};
+
+// ParamEntry contains the i.d. of a declaration and a type that is derived from that declaration,
+// but subject to decay-to-pointer and type parameter renaming
+
 struct ParamEntry {
         ParamEntry(): decl( 0 ), actualType( 0 ), formalType( 0 ), expr( 0 ) {}
@@ -70 +65 @@
 typedef std::map< UniqueId, ParamEntry > InferredParams;
 
-/// ApplicationExpr represents the application of a function to a set of parameters.  This is the
-/// result of running an UntypedExpr through the expression analyzer.
+// ApplicationExpr represents the application of a function to a set of parameters.  This is the
+// result of running an UntypedExpr through the expression analyzer.
+
 class ApplicationExpr : public Expression {
   public:
@@ -93 +89 @@
 };
 
-/// UntypedExpr represents the application of a function to a set of parameters, but where the
-/// particular overload for the function name has not yet been determined.  Most operators are
-/// converted into functional form automatically, to permit operator overloading.
+// UntypedExpr represents the application of a function to a set of parameters, but where the
+// particular overload for the function name has not yet been determined.  Most operators are
+// converted into functional form automatically, to permit operator overloading.
+
 class UntypedExpr : public Expression {
   public:
@@ -121 +118 @@
 };
 
-/// NameExpr contains a name whose meaning is still not determined
+// this class contains a name whose meaning is still not determined
 class NameExpr : public Expression {
   public:
@@ -142 +139 @@
 // function-call format.
 
-/// AddressExpr represents a address-of expression, e.g. &e
+// AddressExpr represents a address-of expression, e.g. &e
 class AddressExpr : public Expression {
   public:
@@ -160 +157 @@
 };
 
-// xxx - this doesn't appear to actually be hooked in anywhere. We should use this instead of the "&&"" UntypedExpr hack
 class LabelAddressExpr : public Expression {
   public:
         LabelAddressExpr( Expression *arg );
-        LabelAddressExpr( const LabelAddressExpr &other );
+        LabelAddressExpr( const AddressExpr &other );
         virtual ~LabelAddressExpr();
 
@@ -178 +174 @@
 };
 
-/// CastExpr represents a type cast expression, e.g. (int)e
+// CastExpr represents a type cast expression, e.g. (int)e
 class CastExpr : public Expression {
   public:
@@ -197 +193 @@
 };
 
-/// UntypedMemberExpr represents a member selection operation, e.g. q.p before processing by the expression analyzer
+// UntypedMemberExpr represents a member selection operation, e.g. q.p before processing by the expression analyzer
 class UntypedMemberExpr : public Expression {
   public:
@@ -218 +214 @@
 };
 
-/// MemberExpr represents a member selection operation, e.g. q.p after processing by the expression analyzer
+// MemberExpr represents a member selection operation, e.g. q.p after processing by the expression analyzer
 class MemberExpr : public Expression {
   public:
@@ -239 +235 @@
 };
 
-/// VariableExpr represents an expression that simply refers to the value of a named variable
+// VariableExpr represents an expression that simply refers to the value of a named variable
 class VariableExpr : public Expression {
   public:
@@ -257 +253 @@
 };
 
-/// ConstantExpr represents an expression that simply refers to the value of a constant
+// ConstantExpr represents an expression that simply refers to the value of a constant 
 class ConstantExpr : public Expression {
   public:
@@ -275 +271 @@
 };
 
-/// SizeofExpr represents a sizeof expression (could be sizeof(int) or sizeof 3+4)
+// SizeofExpr represents a sizeof expression (could be sizeof(int) or sizeof 3+4)
 class SizeofExpr : public Expression {
   public:
@@ -300 +296 @@
 };
 
-/// AlignofExpr represents an alignof expression
-class AlignofExpr : public Expression {
-  public:
-        AlignofExpr( Expression *expr, Expression *_aname = 0 );
-        AlignofExpr( const AlignofExpr &other );
-        AlignofExpr( Type *type, Expression *_aname = 0 );
-        virtual ~AlignofExpr();
-
-        Expression *get_expr() const { return expr; }
-        void set_expr( Expression *newValue ) { expr = newValue; }
-        Type *get_type() const { return type; }
-        void set_type( Type *newValue ) { type = newValue; }
-        bool get_isType() const { return isType; }
-        void set_isType( bool newValue ) { isType = newValue; }
-
-        virtual AlignofExpr *clone() const { return new AlignofExpr( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        Expression *expr;
-        Type *type;
-        bool isType;
-};
-
-/// UntypedOffsetofExpr represents an offsetof expression before resolution
-class UntypedOffsetofExpr : public Expression {
-  public:
-        UntypedOffsetofExpr( Type *type, const std::string &member, Expression *_aname = 0 );
-        UntypedOffsetofExpr( const UntypedOffsetofExpr &other );
-        virtual ~UntypedOffsetofExpr();
-
-        std::string get_member() const { return member; }
-        void set_member( const std::string &newValue ) { member = newValue; }
-        Type *get_type() const { return type; }
-        void set_type( Type *newValue ) { type = newValue; }
-
-        virtual UntypedOffsetofExpr *clone() const { return new UntypedOffsetofExpr( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        Type *type;
-        std::string member;
-};
-
-/// OffsetofExpr represents an offsetof expression
-class OffsetofExpr : public Expression {
-  public:
-        OffsetofExpr( Type *type, DeclarationWithType *member, Expression *_aname = 0 );
-        OffsetofExpr( const OffsetofExpr &other );
-        virtual ~OffsetofExpr();
-
-        Type *get_type() const { return type; }
-        void set_type( Type *newValue ) { type = newValue; }
-        DeclarationWithType *get_member() const { return member; }
-        void set_member( DeclarationWithType *newValue ) { member = newValue; }
-
-        virtual OffsetofExpr *clone() const { return new OffsetofExpr( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        Type *type;
-        DeclarationWithType *member;
-};
-
-/// Expression representing a pack of field-offsets for a generic type
-class OffsetPackExpr : public Expression {
-public:
-        OffsetPackExpr( StructInstType *type_, Expression *aname_ = 0 );
-        OffsetPackExpr( const OffsetPackExpr &other );
-        virtual ~OffsetPackExpr();
-
-        StructInstType *get_type() const { return type; }
-        void set_type( StructInstType *newValue ) { type = newValue; }
-
-        virtual OffsetPackExpr *clone() const { return new OffsetPackExpr( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-
-private:
-        StructInstType *type;
-};
-
-/// AttrExpr represents an @attribute expression (like sizeof, but user-defined)
+// AttrExpr represents an @attribute expression (like sizeof, but user-defined)
 class AttrExpr : public Expression {
   public:
@@ -415 +324 @@
 };
 
-/// LogicalExpr represents a short-circuit boolean expression (&& or ||)
+// LogicalExpr represents a short-circuit boolean expression (&& or ||)
 class LogicalExpr : public Expression {
   public:
@@ -438 +347 @@
 };
 
-/// ConditionalExpr represents the three-argument conditional ( p ? a : b )
+// ConditionalExpr represents the three-argument conditional ( p ? a : b )
 class ConditionalExpr : public Expression {
   public:
@@ -462 +371 @@
 };
 
-/// CommaExpr represents the sequence operator ( a, b )
+// CommaExpr represents the sequence operator ( a, b )
 class CommaExpr : public Expression {
   public:
@@ -483 +392 @@
 };
 
-/// TupleExpr represents a tuple expression ( [a, b, c] )
+// TupleExpr represents a tuple expression ( [a, b, c] )
 class TupleExpr : public Expression {
   public:
@@ -501 +410 @@
 };
 
-/// SolvedTupleExpr represents a TupleExpr whose components have been type-resolved. It is effectively a shell for the code generator to work on
+// SolvedTupleExpr represents a TupleExpr whose components have been type-resolved. It is effectively a shell for the code generator to work on
 class SolvedTupleExpr : public Expression {
   public:
@@ -519 +428 @@
 };
 
-/// TypeExpr represents a type used in an expression (e.g. as a type generator parameter)
+// TypeExpr represents a type used in an expression (e.g. as a type generator parameter)
 class TypeExpr : public Expression {
   public:
@@ -537 +446 @@
 };
 
-/// AsmExpr represents a GCC 'asm constraint operand' used in an asm statement: [output] "=f" (result)
+// AsmExpr represents a GCC 'asm constraint operand' used in an asm statement: [output] "=f" (result)
 class AsmExpr : public Expression {
   public:
         AsmExpr( Expression *inout, ConstantExpr *constraint, Expression *operand ) : inout( inout ), constraint( constraint ), operand( operand ) {}
-        AsmExpr( const AsmExpr & other );
         virtual ~AsmExpr() { delete inout; delete constraint; delete operand; };
 
@@ -564 +472 @@
 };
 
-/// ImplicitCopyCtorExpr represents the application of a function to a set of parameters,
-/// along with a set of copy constructor calls, one for each argument.
-class ImplicitCopyCtorExpr : public Expression {
-public:
-        ImplicitCopyCtorExpr( ApplicationExpr * callExpr );
-        ImplicitCopyCtorExpr( const ImplicitCopyCtorExpr & other );
-        virtual ~ImplicitCopyCtorExpr();
-
-        ApplicationExpr *get_callExpr() const { return callExpr; }
-        void set_callExpr( ApplicationExpr *newValue ) { callExpr = newValue; }
-
-        std::list< ObjectDecl * > & get_tempDecls() { return tempDecls; }
-        void set_tempDecls( std::list< ObjectDecl * > newValue ) { tempDecls = newValue; }
-
-        std::list< ObjectDecl * > & get_returnDecls() { return returnDecls; }
-        void set_returnDecls( std::list< ObjectDecl * > newValue ) { returnDecls = newValue; }
-
-        std::list< Expression * > & get_dtors() { return dtors; }
-        void set_dtors( std::list< Expression * > newValue ) { dtors = newValue; }
-
-        virtual ImplicitCopyCtorExpr *clone() const { return new ImplicitCopyCtorExpr( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        ApplicationExpr * callExpr;
-        std::list< ObjectDecl * > tempDecls;
-        std::list< ObjectDecl * > returnDecls;
-        std::list< Expression * > dtors;
-};
-
-/// ValofExpr represents a GCC 'lambda expression'
+// ValofExpr represents a GCC 'lambda expression'
 class UntypedValofExpr : public Expression {
   public:
         UntypedValofExpr( Statement *_body, Expression *_aname = 0 ) : Expression( _aname ), body ( _body ) {}
-        UntypedValofExpr( const UntypedValofExpr & other );
-        virtual ~UntypedValofExpr();
+        virtual ~UntypedValofExpr() {}
 
         Expression *get_value();
@@ -612 +488 @@
         Statement *body;
 };
-
-/// CompoundLiteralExpr represents a C99 'compound literal'
-class CompoundLiteralExpr : public Expression {
-  public:
-        CompoundLiteralExpr( Type * type, Initializer * initializer );
-        CompoundLiteralExpr( const CompoundLiteralExpr &other );
-        ~CompoundLiteralExpr();
-
-        Type * get_type() const { return type; }
-        void set_type( Type * t ) { type = t; }
-
-        Initializer * get_initializer() const { return initializer; }
-        void set_initializer( Initializer * i ) { initializer = i; }
-
-        virtual CompoundLiteralExpr *clone() const { return new CompoundLiteralExpr( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        Type * type;
-        Initializer * initializer;
-};
-
-class RangeExpr : public Expression {
-  public:
-        RangeExpr( ConstantExpr *low, ConstantExpr *high );
-        RangeExpr( const RangeExpr &other );
-
-        ConstantExpr * get_low() const { return low.get(); }
-        ConstantExpr * get_high() const { return high.get(); }
-        RangeExpr * set_low( ConstantExpr *low ) { RangeExpr::low.reset( low ); return this; }
-        RangeExpr * set_high( ConstantExpr *high ) { RangeExpr::high.reset( high ); return this; }
-
-        virtual RangeExpr *clone() const { return new RangeExpr( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        std::unique_ptr<ConstantExpr> low, high;
-};
-
-std::ostream & operator<<( std::ostream & out, Expression * expr );
 
 #endif // EXPRESSION_H