Changeset d7dc824 for src/SynTree

Timestamp:

Jun 7, 2017, 4:53:42 PM (8 years ago)

Author:

Thierry Delisle <tdelisle@…>

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:

c77fd8b, ec95d11

Parents:

af397ef8

Message:

Removed more warnings

Location:

src/SynTree

Files:

• Expression.h (modified) (1 diff)
• Initializer.cc (modified) (1 diff)
• Initializer.h (modified) (1 diff)
• Mutator.cc (modified) (1 diff)
• Mutator.h (modified) (1 diff)
• SynTree.h (modified) (1 diff)
• TupleExpr.cc (modified) (1 diff)
• Visitor.cc (modified) (1 diff)
• Visitor.h (modified) (1 diff)

src/SynTree/Expression.h

@@ -690 +690 @@
 };
 
-/// 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 {

src/SynTree/Initializer.cc

@@ -33 +33 @@
 }
 
-void Initializer::print( std::ostream &os, int indent ) {}
+// void Initializer::print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent ) {}
 
 SingleInit::SingleInit( Expression *v, const std::list< Expression *> &_designators, bool maybeConstructed ) : Initializer( maybeConstructed ), value ( v ), designators( _designators ) {

src/SynTree/Initializer.h

@@ -53 +53 @@
         virtual void accept( Visitor &v ) = 0;
         virtual Initializer *acceptMutator( Mutator &m ) = 0;
-        virtual void print( std::ostream &os, int indent = 0 );
+        virtual void print( std::ostream &os, int indent = 0 ) = 0;
   private:
         //      std::string name;

src/SynTree/Mutator.cc

@@ -408 +408 @@
 }
 
-Expression *Mutator::mutate( MemberTupleExpr *tupleExpr ) {
-        tupleExpr->set_env( maybeMutate( tupleExpr->get_env(), *this ) );
-        tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
-        tupleExpr->set_member( maybeMutate( tupleExpr->get_member(), *this ) );
-        tupleExpr->set_aggregate( maybeMutate( tupleExpr->get_aggregate(), *this ) );
-        return tupleExpr;
-}
-
 Expression *Mutator::mutate( TupleAssignExpr *assignExpr ) {
         assignExpr->set_env( maybeMutate( assignExpr->get_env(), *this ) );

src/SynTree/Mutator.h

@@ -82 +82 @@
         virtual Expression* mutate( TupleExpr *tupleExpr );
         virtual Expression* mutate( TupleIndexExpr *tupleExpr );
-        virtual Expression* mutate( MemberTupleExpr *tupleExpr );
         virtual Expression* mutate( TupleAssignExpr *assignExpr );
         virtual Expression* mutate( StmtExpr * stmtExpr );

src/SynTree/SynTree.h

@@ -89 +89 @@
 class TupleExpr;
 class TupleIndexExpr;
-class MemberTupleExpr;
 class TupleAssignExpr;
 class StmtExpr;

src/SynTree/TupleExpr.cc

@@ -78 +78 @@
 }
 
-MemberTupleExpr::MemberTupleExpr( Expression * member, Expression * aggregate, Expression * _aname ) : Expression( _aname ) {
-        set_result( maybeClone( member->get_result() ) ); // xxx - ???
-}
-
-MemberTupleExpr::MemberTupleExpr( const MemberTupleExpr &other ) : Expression( other ), member( other.member->clone() ), aggregate( other.aggregate->clone() ) {
-}
-
-MemberTupleExpr::~MemberTupleExpr() {
-        delete member;
-        delete aggregate;
-}
-
-void MemberTupleExpr::print( std::ostream &os, int indent ) const {
-        os << "Member Tuple Expression, with aggregate:" << std::endl;
-        os << std::string( indent+2, ' ' );
-        aggregate->print( os, indent+2 );
-        os << std::string( indent+2, ' ' ) << "with member: " << std::endl;
-        os << std::string( indent+2, ' ' );
-        member->print( os, indent+2 );
-        Expression::print( os, indent );
-}
-
 TupleAssignExpr::TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname ) : Expression( _aname ) {
         // convert internally into a StmtExpr which contains the declarations and produces the tuple of the assignments

src/SynTree/Visitor.cc

@@ -321 +321 @@
 }
 
-void Visitor::visit( MemberTupleExpr *tupleExpr ) {
-        maybeAccept( tupleExpr->get_result(), *this );
-        maybeAccept( tupleExpr->get_member(), *this );
-        maybeAccept( tupleExpr->get_aggregate(), *this );
-}
-
 void Visitor::visit( TupleAssignExpr *assignExpr ) {
         maybeAccept( assignExpr->get_result(), *this );

src/SynTree/Visitor.h

@@ -85 +85 @@
         virtual void visit( TupleExpr *tupleExpr );
         virtual void visit( TupleIndexExpr *tupleExpr );
-        virtual void visit( MemberTupleExpr *tupleExpr );
         virtual void visit( TupleAssignExpr *assignExpr );
         virtual void visit( StmtExpr * stmtExpr );