Changeset fc638d2

Timestamp:

Dec 13, 2016, 4:13:08 PM (6 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

aaron-thesis, arm-eh, 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:

7933351

Parents:

f7e749f

Message:

fixed StmtExpr? code in PolyMutator?, added missing copy constructor, misc documentation

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (1 diff)
• CodeGen/CodeGenerator.h (modified) (1 diff)
• GenPoly/CopyParams.cc (modified) (2 diffs)
• GenPoly/PolyMutator.cc (modified) (1 diff)
• ResolvExpr/TypeEnvironment.cc (modified) (1 diff)
• ResolvExpr/TypeEnvironment.h (modified) (1 diff)
• SymTab/Indexer.h (modified) (1 diff)
• SynTree/CompoundStmt.cc (modified) (1 diff)
• SynTree/Initializer.cc (modified) (1 diff)
• SynTree/Initializer.h (modified) (1 diff)
• SynTree/VarExprReplacer.cc (modified) (1 diff)

src/CodeGen/CodeGenerator.cc

@@ -281 +281 @@
                 } // if
                 output << " }";
+        }
+
+        void CodeGenerator::visit( ConstructorInit * init ){
+                assertf( false, "ConstructorInit nodes should not make it to CodeGen." );
         }
 

src/CodeGen/CodeGenerator.h

@@ -47 +47 @@
                 virtual void visit( SingleInit * );
                 virtual void visit( ListInit * );
+                virtual void visit( ConstructorInit * );
 
                 //*** Constant

src/GenPoly/CopyParams.cc

@@ -38 +38 @@
         };
 
+        /// creates local copies of polymorphic function parameters
         void copyParams( std::list< Declaration* > &translationUnit ) {
                 CopyParams copier;
@@ -53 +54 @@
                         if ( ! modVars.empty() ) {
                                 std::map< std::string, DeclarationWithType* > assignOps;
+                                // xxx - this needs to use constructors, not assignment operators
                                 // assume the assignment operator is the first assert param after any "type" parameter
                                 for ( Type::ForallList::const_iterator tyVar = funcDecl->get_functionType()->get_forall().begin(); tyVar != funcDecl->get_functionType()->get_forall().end(); ++tyVar ) {

src/GenPoly/PolyMutator.cc

@@ -149 +149 @@
                 ValueGuard< std::list< Statement* > > oldStmtsToAdd( stmtsToAdd );
                 ValueGuard< std::list< Statement* > > oldStmtsToAddAfter( stmtsToAddAfter );
+                ValueGuard< TypeSubstitution * > oldEnv( env );
 
-                // xxx - not sure if these are needed, along with appropriate assignments, but I don't think so...
-                // ValueGuard< TyVarMap > oldScopeTyVars;
-                // ValueGuard< TypeSubstitution * > oldEnv;
+                // xxx - not sure if this is needed, along with appropriate reset, but I don't think so...
+                // ValueGuard< TyVarMap > oldScopeTyVars( scopeTyVars );
 
                 stmtsToAdd.clear();
                 stmtsToAddAfter.clear();
+                // scopeTyVars.clear();
 
-                stmtExpr->set_result( maybeMutate( stmtExpr->get_result(), *this ) );
-                stmtExpr->set_statements( maybeMutate( stmtExpr->get_statements(), *this ) );
-                return stmtExpr;
+                return Parent::mutate( stmtExpr );
         }
 

src/ResolvExpr/TypeEnvironment.cc

@@ -32 +32 @@
         //
         // I've seen a TU go from 54 minutes to 1 minute 34 seconds with the addition of this comparator.
-        bool AssertCompare::operator()( DeclarationWithType * d1, DeclarationWithType * d2 ) {
+        bool AssertCompare::operator()( DeclarationWithType * d1, DeclarationWithType * d2 ) const {
                         // Objects are always less than functions
                         if ( ObjectDecl * objectDecl1 = dynamic_cast< ObjectDecl * >( d1 ) ) {

src/ResolvExpr/TypeEnvironment.h

@@ -29 +29 @@
 namespace ResolvExpr {
         struct AssertCompare {
-                bool operator()( DeclarationWithType * d1, DeclarationWithType * d2 );
+                bool operator()( DeclarationWithType * d1, DeclarationWithType * d2 ) const;
         };
         typedef std::map< DeclarationWithType*, bool, AssertCompare > AssertionSet;

src/SymTab/Indexer.h

@@ -25 +25 @@
         class Indexer : public Visitor {
           public:
-                Indexer( bool useDebug = false );
+                explicit Indexer( bool useDebug = false );
 
                 Indexer( const Indexer &that );

src/SynTree/CompoundStmt.cc

@@ -49 +49 @@
                 Statement * origStmt = *origit++;
                 if ( DeclStmt * declStmt = dynamic_cast< DeclStmt * >( s ) ) {
-                        DeclStmt * origDeclStmt = dynamic_cast< DeclStmt * >( origStmt );
-                        assert( origDeclStmt );
+                        DeclStmt * origDeclStmt = safe_dynamic_cast< DeclStmt * >( origStmt );
                         if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * > ( declStmt->get_decl() ) ) {
-                                DeclarationWithType * origdwt = dynamic_cast< DeclarationWithType * > ( origDeclStmt->get_decl() );
-                                assert( origdwt );
+                                DeclarationWithType * origdwt = safe_dynamic_cast< DeclarationWithType * > ( origDeclStmt->get_decl() );
                                 assert( dwt->get_name() == origdwt->get_name() );
                                 declMap[ origdwt ] = dwt;
-                        }
-                }
+                        } else assert( ! dynamic_cast< DeclarationWithType * > ( origDeclStmt->get_decl() ) );
+                } else assert( ! dynamic_cast< DeclStmt * > ( s ) );
         }
         if ( ! declMap.empty() ) {

src/SynTree/Initializer.cc

@@ -65 +65 @@
 }
 
+ListInit::ListInit( const ListInit & other ) : Initializer( other ) {
+        cloneAll( other.initializers, initializers );
+        cloneAll( other.designators, designators );
+}
+
+
 ListInit::~ListInit() {
         deleteAll( initializers );

src/SynTree/Initializer.h

@@ -88 +88 @@
         ListInit( const std::list<Initializer*> &initializers,
                           const std::list<Expression *> &designators = std::list< Expression * >(), bool maybeConstructed = false );
+        ListInit( const ListInit & other );
         virtual ~ListInit();
 

src/SynTree/VarExprReplacer.cc

@@ -21 +21 @@
 // replace variable with new node from decl map
 void VarExprReplacer::visit( VariableExpr * varExpr ) {
+  // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are)
   if ( declMap.count( varExpr->get_var() ) ) {
     varExpr->set_var( declMap.at( varExpr->get_var() ) );