Changeset 70f89d00 for src

Timestamp:

May 30, 2016, 12:51:22 PM (8 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:

f1b1e4c

Parents:

677c1be

Message:

function scoped const objects can be constructed, add missing copy constructors to Initializer.cc

Location:

src

Files:

• InitTweak/GenInit.cc (modified) (3 diffs)
• InitTweak/InitTweak.cc (modified) (1 diff)
• InitTweak/InitTweak.h (modified) (1 diff)
• ResolvExpr/AlternativeFinder.cc (modified) (2 diffs)
• ResolvExpr/Resolver.cc (modified) (1 diff)
• SynTree/Initializer.cc (modified) (4 diffs)
• SynTree/Initializer.h (modified) (7 diffs)

src/InitTweak/GenInit.cc

@@ -143 +143 @@
                 if ( tryConstruct( objDecl ) ) {
                         if ( inFunction ) {
+                                // remove qualifiers so that const objects can be initialized, and attach the
+                                // qualifiers to ConstructorInit so that they can be replaced after resolving
+                                Type * type = objDecl->get_type();
+                                Type::Qualifiers qualifiers = type->get_qualifiers();
+                                type->get_qualifiers() = Type::Qualifiers();
+
                                 if ( ArrayType * at = dynamic_cast< ArrayType * >( objDecl->get_type() ) ) {
                                         // call into makeArrayFunction from validate.cc to generate calls to ctor/dtor for each element of array
@@ -165 +171 @@
                                                 assert( dtor.size() == 1 );
 
-                                                objDecl->set_init( new ConstructorInit( ctor.front(), dtor.front(), objDecl->get_init() ) );
+                                                objDecl->set_init( new ConstructorInit( ctor.front(), dtor.front(), objDecl->get_init(), objDecl, qualifiers ) );
                                         } else {
                                                 // array came with an initializer list: initialize each element
@@ -185 +191 @@
                                         ExprStmt * ctorStmt = new ExprStmt( noLabels, ctor );
                                         ExprStmt * dtorStmt = new ExprStmt( noLabels, dtor );
-                                        objDecl->set_init( new ConstructorInit( ctorStmt, dtorStmt, objDecl->get_init() ) );
+                                        objDecl->set_init( new ConstructorInit( ctorStmt, dtorStmt, objDecl->get_init(), objDecl, qualifiers ) );
                                 }
                         }

src/InitTweak/InitTweak.cc

@@ -83 +83 @@
     }
   }
+
+  namespace {
+    template<typename CallExpr>
+    std::string funcName( CallExpr * expr ) {
+      Expression * func = expr->get_function();
+      if ( NameExpr * nameExpr = dynamic_cast< NameExpr * >( func ) ) {
+        return nameExpr->get_name();
+      } else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( func ) ) {
+        return varExpr->get_var()->get_name();
+      } else {
+        assert( false && "Unexpected expression type being called as a function in call expression" );
+      }
+    }
+  }
+
+  std::string getFunctionName( Expression * expr ) {
+    if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr ) ) {
+      return funcName( appExpr );
+    } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * > ( expr ) ) {
+      return funcName( untypedExpr );
+    } else {
+      assert( false && "Unexpected expression type passed to getFunctionName" );
+    }
+  }
 }

src/InitTweak/InitTweak.h

@@ -39 +39 @@
   /// Currently has assertions that make it less than fully general.
   bool isInstrinsicSingleArgCallStmt( Statement * expr );
+
+  /// returns the name of the function being called
+  std::string getFunctionName(Expression * expr);
 } // namespace
 

src/ResolvExpr/AlternativeFinder.cc

@@ -39 +39 @@
 #include "Tuples/NameMatcher.h"
 #include "Common/utility.h"
+#include "InitTweak/InitTweak.h"
 
 extern bool resolvep;
@@ -546 +547 @@
 
                 {
-                        NameExpr *fname = 0;;
-                        if ( ( fname = dynamic_cast<NameExpr *>( untypedExpr->get_function()))
-                                 && ( fname->get_name() == std::string("&&")) ) {
+                        std::string fname = InitTweak::getFunctionName( untypedExpr );
+                        if ( fname == "&&" ) {
                                 VoidType v = Type::Qualifiers();                // resolve to type void *
                                 PointerType pt( Type::Qualifiers(), v.clone() );

src/ResolvExpr/Resolver.cc

@@ -492 +492 @@
                 } catch ( SemanticError ) {
                         // no alternatives for the constructor initializer - fallback on C-style initializer
-                        // xxx- not sure if this makes a ton of sense - should maybe never be able to have this situation?
+                        // xxx - not sure if this makes a ton of sense - should maybe never be able to have this situation?
+
+                        // reset type qualifiers
+                        ctorInit->get_object()->get_type()->get_qualifiers() = ctorInit->get_qualifiers();
                         fallbackInit( ctorInit );
                         return;
                 }
+                // reset type qualifiers
+                ctorInit->get_object()->get_type()->get_qualifiers() = ctorInit->get_qualifiers();
 
                 // found a constructor - can get rid of C-style initializer

src/SynTree/Initializer.cc

@@ -20 +20 @@
 
 Initializer::Initializer( bool maybeConstructed ) : maybeConstructed( maybeConstructed ) {}
+Initializer::Initializer( const Initializer & other ) : maybeConstructed( other.maybeConstructed ) {
+}
+
 
 Initializer::~Initializer() {}
@@ -39 +42 @@
 }
 
-SingleInit::~SingleInit() {}
-
-SingleInit *SingleInit::clone() const { return new SingleInit( *this); }
+SingleInit::~SingleInit() {
+        deleteAll(designators);
+}
 
 void SingleInit::print( std::ostream &os, int indent ) {
@@ -58 +61 @@
 
 ListInit::ListInit( const std::list<Initializer*> &_initializers, const std::list<Expression *> &_designators, bool maybeConstructed )
-        : Initializer( maybeConstructed), initializers( _initializers ), designators( _designators ) {
+        : Initializer( maybeConstructed ), initializers( _initializers ), designators( _designators ) {
 }
 
-ListInit::~ListInit() {}
-
-ListInit *ListInit::clone() const {
-        return new ListInit( *this );
+ListInit::~ListInit() {
+        deleteAll( initializers );
+        deleteAll( designators );
 }
 
@@ -84 +86 @@
 
 
-ConstructorInit::ConstructorInit( Statement * ctor, Statement * dtor, Initializer * init ) : Initializer( true ), ctor( ctor ), dtor( dtor ), init( init ) {}
+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() {
         delete ctor;
+        delete dtor;
         delete init;
-}
-
-ConstructorInit *ConstructorInit::clone() const {
-        return new ConstructorInit( *this );
 }
 

src/SynTree/Initializer.h

@@ -20 +20 @@
 #include "Visitor.h"
 #include "Mutator.h"
+#include "Type.h"
 
 #include <cassert>
@@ -28 +29 @@
         //      Initializer( std::string _name = std::string(""), int _pos = 0 );
         Initializer( bool maybeConstructed );
+        Initializer( const Initializer & other );
         virtual ~Initializer();
 
@@ -68 +70 @@
         std::list<Expression *> &get_designators() { return designators; }
 
-        virtual SingleInit *clone() const;
+        virtual SingleInit *clone() const { return new SingleInit( *this); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
@@ -94 +96 @@
         std::list<Initializer*>::iterator end_initializers() { return initializers.end(); }
 
-        virtual ListInit *clone() const;
+        virtual ListInit *clone() const { return new ListInit( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
@@ -107 +109 @@
 class ConstructorInit : public Initializer {
   public:
-        ConstructorInit( Statement * ctor, Statement * dtor, Initializer * init );
+        ConstructorInit( Statement * ctor, Statement * dtor, Initializer * init, ObjectDecl * objectDecl, Type::Qualifiers qualifiers );
+        ConstructorInit( const ConstructorInit &other );
         virtual ~ConstructorInit();
 
@@ -116 +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; }
 
-        virtual ConstructorInit *clone() const;
+        ConstructorInit *clone() const { return new ConstructorInit( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
@@ -128 +135 @@
         // 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;
 };