Changes in src/SynTree/Expression.h [b6fe7e6:3b58d91]

File:

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

src/SynTree/Expression.h

@@ -200 +200 @@
 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 +214 @@
         virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
-        std::string member;
+        Expression *member;
         Expression *aggregate;
 };
@@ -595 +595 @@
 };
 
-/// ConstructorExpr represents the use of a constructor in an expression context, e.g. int * x = malloc() { 5 };
-class ConstructorExpr : public Expression {
-public:
-        ConstructorExpr( Expression * callExpr );
-        ConstructorExpr( const ConstructorExpr & other );
-        ~ConstructorExpr();
-
-        Expression *get_callExpr() const { return callExpr; }
-        void set_callExpr( Expression *newValue ) { callExpr = newValue; }
-
-        virtual ConstructorExpr *clone() const { return new ConstructorExpr( *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 * callExpr;
-};
-
-/// 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;
-};
-
 /// ValofExpr represents a GCC 'lambda expression'
 class UntypedValofExpr : public Expression {
@@ -653 +613 @@
 };
 
-/// RangeExpr represents a range e.g. '3 ... 5' or '1~10'
+/// CompoundLiteralExpr represents a C99 'compound literal'
+class CompoundLiteralExpr : public Expression {
+  public:
+        CompoundLiteralExpr( Type * type, Initializer * initializer );
+        CompoundLiteralExpr( const CompoundLiteralExpr &other );
+        virtual ~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:
@@ -670 +651 @@
   private:
         Expression *low, *high;
+};
+
+/// 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;
+};
+
+/// MultipleAssignExpr represents a multiple assignment operation, where both sides of the assignment have tuple type, e.g. [a, b, c] = [d, e, f];
+class MultipleAssignExpr : public Expression {
+  public:
+        MultipleAssignExpr( Expression * lhs, Expression * rhs );
+        MultipleAssignExpr( const MultipleAssignExpr &other );
+        virtual ~MultipleAssignExpr();
+
+        Expression * get_lhs() const { return lhs; }
+        Expression * get_rhs() const { return rhs; }
+        MultipleAssignExpr * set_lhs( Expression *newValue ) { lhs = newValue; return this; }
+        MultipleAssignExpr * set_rhs( Expression *newValue ) { rhs = newValue; return this; }
+
+        virtual MultipleAssignExpr *clone() const { return new MultipleAssignExpr( *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 * lhs;
+        Expression * rhs;
+};
+
+/// MassAssignExpr represents a mass assignment operations, where the left hand side has tuple type and the right hand side does not, e.g. [a, b, c] = 5.0;
+class MassAssignExpr : public Expression {
+  public:
+        MassAssignExpr( Expression * tuple, int field );
+        MassAssignExpr( const MassAssignExpr &other );
+        virtual ~MassAssignExpr();
+
+        Expression * get_lhs() const { return lhs; }
+        Expression * get_rhs() const { return rhs; }
+        MassAssignExpr * set_lhs( Expression *newValue ) { lhs = newValue; return this; }
+        MassAssignExpr * set_rhs( Expression *newValue ) { rhs = newValue; return this; }
+
+        virtual MassAssignExpr *clone() const { return new MassAssignExpr( *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 * lhs; // multiple exprs
+        Expression * rhs; // single expr
 };