Changeset f1b1e4c for src/SynTree

Timestamp:

Jun 1, 2016, 11:54:23 AM (9 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

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

Children:

be945ac

Parents:

70f89d00

Message:

can construct global const objects, except with intrinsic constructors

Location:

src/SynTree

Files:

• Initializer.cc (modified) (1 diff)
• Initializer.h (modified) (3 diffs)
• Mutator.cc (modified) (1 diff)
• Mutator.h (modified) (1 diff)
• Statement.cc (modified) (3 diffs)
• Statement.h (modified) (3 diffs)
• SynTree.h (modified) (1 diff)
• Type.cc (modified) (3 diffs)
• Type.h (modified) (1 diff)
• Visitor.cc (modified) (1 diff)
• Visitor.h (modified) (1 diff)

src/SynTree/Initializer.cc

@@ -86 +86 @@
 
 
-ConstructorInit::ConstructorInit( Statement * ctor, Statement * dtor, Initializer * init, ObjectDecl * object, Type::Qualifiers qualifiers ) : Initializer( true ), ctor( ctor ), dtor( dtor ), init( init ), object( object ), qualifiers( qualifiers ) {}
-ConstructorInit::ConstructorInit( const ConstructorInit &other ) : Initializer( other ), ctor( maybeClone( other.ctor ) ), dtor( maybeClone( other.dtor ) ), init( maybeClone( other.init ) ), object( other.object ), qualifiers( other.qualifiers ) {
+ConstructorInit::ConstructorInit( Statement * ctor, Statement * dtor, Initializer * init ) : Initializer( true ), ctor( ctor ), dtor( dtor ), init( init ) {}
+ConstructorInit::ConstructorInit( const ConstructorInit &other ) : Initializer( other ), ctor( maybeClone( other.ctor ) ), dtor( maybeClone( other.dtor ) ), init( maybeClone( other.init ) ) {
 }
 

src/SynTree/Initializer.h

@@ -109 +109 @@
 class ConstructorInit : public Initializer {
   public:
-        ConstructorInit( Statement * ctor, Statement * dtor, Initializer * init, ObjectDecl * objectDecl, Type::Qualifiers qualifiers );
+        ConstructorInit( Statement * ctor, Statement * dtor, Initializer * init );
         ConstructorInit( const ConstructorInit &other );
         virtual ~ConstructorInit();
@@ -119 +119 @@
         void set_init( Initializer * newValue ) { init = newValue; }
         Initializer * get_init() const { return init; }
-        void set_object( ObjectDecl * newValue ) { object = newValue; }
-        ObjectDecl * get_object() const { return object; }
-        void set_qualifiers( Type::Qualifiers newValue ) { qualifiers = newValue; }
-        Type::Qualifiers get_qualifiers() { return qualifiers; }
 
         ConstructorInit *clone() const { return new ConstructorInit( *this ); }
@@ -135 +131 @@
         // if an appropriate constructor definition is not found by the resolver
         Initializer * init;
-        // Non-owned pointer back to the object being constructed
-        ObjectDecl * object;
-        // to construct const objects, need to first remove type qualifiers, then resolve
-        // then add qualifiers back onto object
-        Type::Qualifiers qualifiers;
 };
 

src/SynTree/Mutator.cc

@@ -182 +182 @@
 }
 
+Statement *Mutator::mutate( ImplicitCtorDtorStmt *impCtorDtorStmt ) {
+        impCtorDtorStmt->set_callStmt( maybeMutate( impCtorDtorStmt->get_callStmt(), *this ) );
+        return impCtorDtorStmt;
+}
+
 Expression *Mutator::mutate( ApplicationExpr *applicationExpr ) {
         mutateAll( applicationExpr->get_results(), *this );

src/SynTree/Mutator.h

@@ -52 +52 @@
         virtual NullStmt* mutate( NullStmt *nullStmt );
         virtual Statement* mutate( DeclStmt *declStmt );
+        virtual Statement* mutate( ImplicitCtorDtorStmt *impCtorDtorStmt );
 
         virtual Expression* mutate( ApplicationExpr *applicationExpr );

src/SynTree/Statement.cc

@@ -358 +358 @@
 
 void CatchStmt::print( std::ostream &os, int indent ) const {
-        os << string( indent, ' ' ) << "Catch Statement" << endl;
+        os << "Catch Statement" << endl;
 
         os << string( indent, ' ' ) << "... catching" << endl;
@@ -383 +383 @@
 
 void FinallyStmt::print( std::ostream &os, int indent ) const {
-        os << string( indent, ' ' ) << "Finally Statement" << endl;
+        os << "Finally Statement" << endl;
         os << string( indent + 2, ' ' ) << "with block: " << endl;
         block->print( os, indent + 4 );
@@ -393 +393 @@
 void NullStmt::print( std::ostream &os, int indent ) const {
         os << "Null Statement" << endl ;
+}
+
+ImplicitCtorDtorStmt::ImplicitCtorDtorStmt( Statement * callStmt ) : Statement( std::list<Label>() ), callStmt( callStmt ) {
+        assert( callStmt );
+}
+
+ImplicitCtorDtorStmt::ImplicitCtorDtorStmt( const ImplicitCtorDtorStmt & other ) : Statement( other ), callStmt( other.callStmt ) {
+}
+
+ImplicitCtorDtorStmt::~ImplicitCtorDtorStmt() {
+}
+
+void ImplicitCtorDtorStmt::print( std::ostream &os, int indent ) const {
+        os << "Implicit Ctor Dtor Statement" << endl;
+        os << string( indent + 2, ' ' ) << "with Ctor/Dtor: ";
+        callStmt->print( os, indent + 2);
+        os << endl;
 }
 

src/SynTree/Statement.h

@@ -21 +21 @@
 #include "Mutator.h"
 #include "Common/SemanticError.h"
+#include "Type.h"
 
 class Statement {
@@ -394 +395 @@
         virtual ~DeclStmt();
 
-        Declaration *get_decl() { return decl; }
+        Declaration *get_decl() const { return decl; }
         void set_decl( Declaration *newValue ) { decl = newValue; }
 
@@ -404 +405 @@
         Declaration *decl;
 };
+
+
+/// represents an implicit application of a constructor or destructor. Qualifiers are replaced
+/// immediately before and after the call so that qualified objects can be constructed
+/// with the same functions as unqualified objects.
+class ImplicitCtorDtorStmt : public Statement {
+  public:
+        ImplicitCtorDtorStmt( Statement * callStmt );
+        ImplicitCtorDtorStmt( const ImplicitCtorDtorStmt & other );
+        virtual ~ImplicitCtorDtorStmt();
+
+        Statement *get_callStmt() const { return callStmt; }
+        void set_callStmt( Statement * newValue ) { callStmt = newValue; }
+
+        virtual ImplicitCtorDtorStmt *clone() const { return new ImplicitCtorDtorStmt( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+
+  private:
+        // Non-owned pointer to the constructor/destructor statement
+        Statement * callStmt;
+};
+
 
 std::ostream & operator<<( std::ostream & out, Statement * statement );

src/SynTree/SynTree.h

@@ -56 +56 @@
 class DeclStmt;
 class NullStmt;
+class ImplicitCtorDtorStmt;
 
 class Expression;

src/SynTree/Type.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Type.cc -- 
+// Type.cc --
 //
 // Author           : Richard C. Bilson
@@ -54 +54 @@
 }
 
+void Type::Qualifiers::print( std::ostream &os, int indent ) const {
+        if ( isConst ) {
+                os << "const ";
+        } // if
+        if ( isVolatile ) {
+                os << "volatile ";
+        } // if
+        if ( isRestrict ) {
+                os << "restrict ";
+        } // if
+        if ( isLvalue ) {
+                os << "lvalue ";
+        } // if
+        if ( isAtomic ) {
+                os << "_Atomic ";
+        } // if
+        if ( isAttribute ) {
+                os << "__attribute(( )) ";
+        } // if
+}
+
 void Type::print( std::ostream &os, int indent ) const {
         if ( ! forall.empty() ) {
@@ -60 +81 @@
                 os << std::string( indent+2, ' ' );
         } // if
-        if ( tq.isConst ) {
-                os << "const ";
-        } // if
-        if ( tq.isVolatile ) {
-                os << "volatile ";
-        } // if
-        if ( tq.isRestrict ) {
-                os << "restrict ";
-        } // if
-        if ( tq.isLvalue ) {
-                os << "lvalue ";
-        } // if
-        if ( tq.isAtomic ) {
-                os << "_Atomic ";
-        } // if
-        if ( tq.isAttribute ) {
-                os << "__attribute(( )) ";
-        } // if
+        tq.print( os, indent );
 }
 

src/SynTree/Type.h

@@ -36 +36 @@
                 bool operator<( const Qualifiers &other );
                 bool operator>( const Qualifiers &other );
+                void print( std::ostream &os, int indent = 0 ) const;
 
                 bool isConst;

src/SynTree/Visitor.cc

@@ -152 +152 @@
 }
 
+void Visitor::visit( ImplicitCtorDtorStmt *impCtorDtorStmt ) {
+        maybeAccept( impCtorDtorStmt->get_callStmt(), *this );
+}
+
 void Visitor::visit( ApplicationExpr *applicationExpr ) {
         acceptAll( applicationExpr->get_results(), *this );

src/SynTree/Visitor.h

@@ -52 +52 @@
         virtual void visit( NullStmt *nullStmt );
         virtual void visit( DeclStmt *declStmt );
+        virtual void visit( ImplicitCtorDtorStmt *impCtorDtorStmt );
 
         virtual void visit( ApplicationExpr *applicationExpr );