Changes in src/SynTree/Expression.h [af5c204a:e4d829b]

File:

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

src/SynTree/Expression.h

@@ -226 +226 @@
 };
 
-/// MemberExpr represents a member selection operation, e.g. q.p after processing by the expression analyzer.
-/// Does not take ownership of member.
+/// MemberExpr represents a member selection operation, e.g. q.p after processing by the expression analyzer
 class MemberExpr : public Expression {
   public:
@@ -248 +247 @@
 };
 
-/// VariableExpr represents an expression that simply refers to the value of a named variable.
-/// Does not take ownership of var.
+/// VariableExpr represents an expression that simply refers to the value of a named variable
 class VariableExpr : public Expression {
   public:
@@ -600 +598 @@
 };
 
+/// ValofExpr represents a GCC 'lambda expression'
+class UntypedValofExpr : public Expression {
+  public:
+        UntypedValofExpr( Statement *_body, Expression *_aname = nullptr ) : Expression( _aname ), body ( _body ) {}
+        UntypedValofExpr( const UntypedValofExpr & other );
+        virtual ~UntypedValofExpr();
+
+        Expression * get_value();
+        Statement * get_body() const { return body; }
+
+        virtual UntypedValofExpr * clone() const { return new UntypedValofExpr( * 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:
+        Statement * body;
+};
+
 /// RangeExpr represents a range e.g. '3 ... 5' or '1~10'
 class RangeExpr : public Expression {
@@ -672 +688 @@
         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;
 };
 
@@ -744 +781 @@
 };
 
+struct InitAlternative {
+public:
+        Type * type = nullptr;
+        Designation * designation = nullptr;
+        InitAlternative( Type * type, Designation * designation );
+        InitAlternative( const InitAlternative & other );
+        InitAlternative & operator=( const Initializer & other ) = delete; // at the moment this isn't used, and I don't want to implement it
+        ~InitAlternative();
+};
+
+class UntypedInitExpr : public Expression {
+public:
+        UntypedInitExpr( Expression * expr, const std::list<InitAlternative> & initAlts );
+        UntypedInitExpr( const UntypedInitExpr & other );
+        ~UntypedInitExpr();
+
+        Expression * get_expr() const { return expr; }
+        UntypedInitExpr * set_expr( Expression * newValue ) { expr = newValue; return this; }
+
+        std::list<InitAlternative> & get_initAlts() { return initAlts; }
+
+        virtual UntypedInitExpr * clone() const { return new UntypedInitExpr( * 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;
+        std::list<InitAlternative> initAlts;
+};
+
+class InitExpr : public Expression {
+public:
+        InitExpr( Expression * expr, Type * type, Designation * designation );
+        InitExpr( const InitExpr & other );
+        ~InitExpr();
+
+        Expression * get_expr() const { return expr; }
+        InitExpr * set_expr( Expression * newValue ) { expr = newValue; return this; }
+
+        Designation * get_designation() const { return designation; }
+        InitExpr * set_designation( Designation * newValue ) { designation = newValue; return this; }
+
+        virtual InitExpr * clone() const { return new InitExpr( * 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;
+        Designation * designation;
+};
+
+
 std::ostream & operator<<( std::ostream & out, const Expression * expr );