Changeset 1f44196 for src/SynTree/Expression.h

Timestamp:

Nov 29, 2016, 3:30:59 PM (9 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

8e5724e

Parents:

3a2128f (diff), 9129a84 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg2:software/cfa/cfa-cc

Conflicts:

src/Parser/parser.cc

File:

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

src/SynTree/Expression.h

@@ -32 +32 @@
         virtual ~Expression();
 
-        std::list<Type *>& get_results() { return results; }
-        void add_result( Type *t );
+        Type *& get_result() { return result; }
+        void set_result( Type *newValue ) { result = newValue; }
+        bool has_result() const { return result != nullptr; }
 
         TypeSubstitution *get_env() const { return env; }
@@ -47 +48 @@
         virtual void print( std::ostream &os, int indent = 0 ) const;
   protected:
-        std::list<Type *> results;
+        Type * result;
         TypeSubstitution *env;
         Expression* argName; // if expression is used as an argument, it can be "designated" by this name
@@ -98 +99 @@
 class UntypedExpr : public Expression {
   public:
-        UntypedExpr( Expression *function, Expression *_aname = nullptr );
+        UntypedExpr( Expression *function, const std::list<Expression *> &args = std::list< Expression * >(), Expression *_aname = nullptr );
         UntypedExpr( const UntypedExpr &other );
-        UntypedExpr( Expression *function, std::list<Expression *> &args, Expression *_aname = nullptr );
         virtual ~UntypedExpr();
 
@@ -111 +111 @@
         std::list<Expression*>& get_args() { return args; }
 
+        static UntypedExpr * createDeref( Expression * arg );
+        static UntypedExpr * createAssign( Expression * arg1, Expression * arg2 );
+
         virtual UntypedExpr *clone() const { return new UntypedExpr( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
@@ -200 +203 @@
 class UntypedMemberExpr : public Expression {
   public:
-        UntypedMemberExpr( std::string member, Expression *aggregate, Expression *_aname = nullptr );
+        UntypedMemberExpr( Expression *member, Expression *aggregate, Expression *_aname = nullptr );
         UntypedMemberExpr( const UntypedMemberExpr &other );
         virtual ~UntypedMemberExpr();
 
-        std::string get_member() const { return member; }
-        void set_member( const std::string &newValue ) { member = newValue; }
+        Expression * get_member() const { return member; }
+        void set_member( Expression * newValue ) { member = newValue; }
         Expression *get_aggregate() const { return aggregate; }
         void set_aggregate( Expression *newValue ) { aggregate = newValue; }
@@ -214 +217 @@
         virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
-        std::string member;
+        Expression *member;
         Expression *aggregate;
 };
@@ -483 +486 @@
 };
 
-/// TupleExpr represents a tuple expression ( [a, b, c] )
-class TupleExpr : public Expression {
-  public:
-        TupleExpr( Expression *_aname = nullptr );
-        TupleExpr( const TupleExpr &other );
-        virtual ~TupleExpr();
-
-        void set_exprs( std::list<Expression*> newValue ) { exprs = newValue; }
-        std::list<Expression*>& get_exprs() { return exprs; }
-
-        virtual TupleExpr *clone() const { return new TupleExpr( *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::list<Expression*> exprs;
-};
-
-/// 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:
-        SolvedTupleExpr( Expression *_aname = nullptr ) : Expression( _aname ) {}
-        SolvedTupleExpr( std::list<Expression *> &, Expression *_aname = nullptr );
-        SolvedTupleExpr( const SolvedTupleExpr &other );
-        virtual ~SolvedTupleExpr() {}
-
-        std::list<Expression*> &get_exprs() { return exprs; }
-
-        virtual SolvedTupleExpr *clone() const { return new SolvedTupleExpr( *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::list<Expression*> exprs;
-};
-
 /// TypeExpr represents a type used in an expression (e.g. as a type generator parameter)
 class TypeExpr : public Expression {
@@ -618 +585 @@
         CompoundLiteralExpr( Type * type, Initializer * initializer );
         CompoundLiteralExpr( const CompoundLiteralExpr &other );
-        ~CompoundLiteralExpr();
+        virtual ~CompoundLiteralExpr();
 
         Type * get_type() const { return type; }
@@ -670 +637 @@
   private:
         Expression *low, *high;
+};
+
+/// TupleExpr represents a tuple expression ( [a, b, c] )
+class TupleExpr : public Expression {
+  public:
+        TupleExpr( const std::list< Expression * > & exprs = std::list< Expression * >(), Expression *_aname = nullptr );
+        TupleExpr( const TupleExpr &other );
+        virtual ~TupleExpr();
+
+        void set_exprs( std::list<Expression*> newValue ) { exprs = newValue; }
+        std::list<Expression*>& get_exprs() { return exprs; }
+
+        virtual TupleExpr *clone() const { return new TupleExpr( *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::list<Expression*> exprs;
+};
+
+/// TupleIndexExpr represents an element selection operation on a tuple value, e.g. t.3 after processing by the expression analyzer
+class TupleIndexExpr : public Expression {
+  public:
+        TupleIndexExpr( Expression * tuple, unsigned int index );
+        TupleIndexExpr( const TupleIndexExpr &other );
+        virtual ~TupleIndexExpr();
+
+        Expression * get_tuple() const { return tuple; }
+        int get_index() const { return index; }
+        TupleIndexExpr * set_tuple( Expression *newValue ) { tuple = newValue; return this; }
+        TupleIndexExpr * set_index( unsigned int newValue ) { index = newValue; return this; }
+
+        virtual TupleIndexExpr *clone() const { return new TupleIndexExpr( *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 * tuple;
+        unsigned int index;
+};
+
+/// MemberTupleExpr represents a tuple member selection operation on a struct type, e.g. s.[a, b, c] after processing by the expression analyzer
+class MemberTupleExpr : public Expression {
+  public:
+        MemberTupleExpr( Expression * member, Expression * aggregate, Expression * _aname = nullptr );
+        MemberTupleExpr( const MemberTupleExpr &other );
+        virtual ~MemberTupleExpr();
+
+        Expression * get_member() const { return member; }
+        Expression * get_aggregate() const { return aggregate; }
+        MemberTupleExpr * set_member( Expression *newValue ) { member = newValue; return this; }
+        MemberTupleExpr * set_aggregate( Expression *newValue ) { aggregate = newValue; return this; }
+
+        virtual MemberTupleExpr *clone() const { return new MemberTupleExpr( *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 * member;
+        Expression * aggregate;
+};
+
+/// TupleAssignExpr represents a multiple assignment operation, where both sides of the assignment have tuple type, e.g. [a, b, c] = [d, e, f];, a mass assignment operation, where the left hand side has tuple type and the right hand side does not, e.g. [a, b, c] = 5.0;, or a tuple ctor/dtor expression
+class TupleAssignExpr : public Expression {
+  public:
+        TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname = nullptr );
+        TupleAssignExpr( const TupleAssignExpr &other );
+        virtual ~TupleAssignExpr();
+
+        std::list< Expression * > & get_assigns() { return assigns; }
+        std::list< ObjectDecl * > & get_tempDecls() { return tempDecls; }
+
+        virtual TupleAssignExpr *clone() const { return new TupleAssignExpr( *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::list< Expression * > assigns; // assignment expressions that use tempDecls
+        std::list< ObjectDecl * > tempDecls; // temporaries for address of lhs exprs
+};
+
+/// StmtExpr represents a GCC 'statement expression', e.g. ({ int x = 5; x; })
+class StmtExpr : public Expression {
+public:
+        StmtExpr( CompoundStmt *statements );
+        StmtExpr( const StmtExpr & other );
+        virtual ~StmtExpr();
+
+        CompoundStmt * get_statements() const { return statements; }
+        StmtExpr * set_statements( CompoundStmt * newValue ) { statements = newValue; return this; }
+
+        virtual StmtExpr *clone() const { return new StmtExpr( *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:
+        CompoundStmt * statements;
+};
+
+class UniqueExpr : public Expression {
+public:
+        UniqueExpr( Expression * expr, long long idVal = -1 );
+        UniqueExpr( const UniqueExpr & other );
+        ~UniqueExpr();
+
+        Expression * get_expr() const { return expr; }
+        UniqueExpr * set_expr( Expression * newValue ) { expr = newValue; return this; }
+
+        ObjectDecl * get_object() const { return object; }
+        UniqueExpr * set_object( ObjectDecl * newValue ) { object = newValue; return this; }
+
+        VariableExpr * get_var() const { return var; }
+        UniqueExpr * set_var( VariableExpr * newValue ) { var = newValue; return this; }
+
+        int get_id() const { return id; }
+
+        virtual UniqueExpr *clone() const { return new UniqueExpr( *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;
+        ObjectDecl * object;
+        VariableExpr * var;
+        int id;
+        static long long count;
 };