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

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 : Fri Jul 24 13:49:28 2015
-// Update Count     : 18
+// Last Modified On : Wed Aug  3 17:08:44 2016
+// Update Count     : 27
 //
 
@@ -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:
@@ -36 +39 @@
         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;
@@ -45 +50 @@
         TypeSubstitution *env;
         Expression* argName; // if expression is used as an argument, it can be "designated" by this name
-};
-
-// 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
-
+        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
 struct ParamEntry {
         ParamEntry(): decl( 0 ), actualType( 0 ), formalType( 0 ), expr( 0 ) {}
@@ -65 +70 @@
 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:
@@ -89 +93 @@
 };
 
-// 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:
@@ -118 +121 @@
 };
 
-// this class contains a name whose meaning is still not determined
+/// NameExpr contains a name whose meaning is still not determined
 class NameExpr : public Expression {
   public:
@@ -139 +142 @@
 // 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:
@@ -157 +160 @@
 };
 
+// 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 AddressExpr &other );
+        LabelAddressExpr( const LabelAddressExpr &other );
         virtual ~LabelAddressExpr();
 
@@ -174 +178 @@
 };
 
-// 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:
@@ -193 +197 @@
 };
 
-// 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:
@@ -214 +218 @@
 };
 
-// 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:
@@ -235 +239 @@
 };
 
-// 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:
@@ -253 +257 @@
 };
 
-// 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:
@@ -271 +275 @@
 };
 
-// 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:
@@ -296 +300 @@
 };
 
-// AttrExpr represents an @attribute expression (like sizeof, but user-defined)
+/// 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)
 class AttrExpr : public Expression {
   public:
@@ -324 +415 @@
 };
 
-// LogicalExpr represents a short-circuit boolean expression (&& or ||)
+/// LogicalExpr represents a short-circuit boolean expression (&& or ||)
 class LogicalExpr : public Expression {
   public:
@@ -347 +438 @@
 };
 
-// ConditionalExpr represents the three-argument conditional ( p ? a : b )
+/// ConditionalExpr represents the three-argument conditional ( p ? a : b )
 class ConditionalExpr : public Expression {
   public:
@@ -371 +462 @@
 };
 
-// CommaExpr represents the sequence operator ( a, b )
+/// CommaExpr represents the sequence operator ( a, b )
 class CommaExpr : public Expression {
   public:
@@ -392 +483 @@
 };
 
-// TupleExpr represents a tuple expression ( [a, b, c] )
+/// TupleExpr represents a tuple expression ( [a, b, c] )
 class TupleExpr : public Expression {
   public:
@@ -410 +501 @@
 };
 
-// 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:
@@ -428 +519 @@
 };
 
-// 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:
@@ -446 +537 @@
 };
 
-// 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; };
 
@@ -472 +564 @@
 };
 
-// ValofExpr represents a GCC 'lambda expression'
+/// 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'
 class UntypedValofExpr : public Expression {
   public:
         UntypedValofExpr( Statement *_body, Expression *_aname = 0 ) : Expression( _aname ), body ( _body ) {}
-        virtual ~UntypedValofExpr() {}
+        UntypedValofExpr( const UntypedValofExpr & other );
+        virtual ~UntypedValofExpr();
 
         Expression *get_value();
@@ -488 +612 @@
         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