Changes in src/ResolvExpr/Resolver.cc [435e75f:6013bd7]

File:

• src/ResolvExpr/Resolver.cc (modified) (9 diffs)

src/ResolvExpr/Resolver.cc

@@ -14 +14 @@
 //
 
-#include <iostream>
-
+#include "Resolver.h"
+#include "AlternativeFinder.h"
 #include "Alternative.h"
-#include "AlternativeFinder.h"
-#include "CurrentObject.h"
 #include "RenameVars.h"
-#include "Resolver.h"
 #include "ResolveTypeof.h"
 #include "typeops.h"
-
+#include "SynTree/Statement.h"
+#include "SynTree/Type.h"
 #include "SynTree/Expression.h"
 #include "SynTree/Initializer.h"
-#include "SynTree/Statement.h"
-#include "SynTree/Type.h"
-
+#include "SymTab/Indexer.h"
 #include "SymTab/Autogen.h"
-#include "SymTab/Indexer.h"
-
 #include "Common/utility.h"
-
 #include "InitTweak/InitTweak.h"
 
+#include <iostream>
 using namespace std;
 
@@ -45 +39 @@
                         if ( const Resolver * res = dynamic_cast< const Resolver * >( &other ) ) {
                                 functionReturn = res->functionReturn;
-                                currentObject = res->currentObject;
+                                initContext = res->initContext;
                                 inEnumDecl = res->inEnumDecl;
                         }
@@ -85 +79 @@
 
                 Type * functionReturn = nullptr;
-                CurrentObject currentObject = nullptr;
+                Type *initContext = nullptr;
                 bool inEnumDecl = false;
         };
@@ -130 +124 @@
                         } // if
 #endif
-                        assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end." );
+                        assert( finder.get_alternatives().size() == 1 );
                         Alternative &choice = finder.get_alternatives().front();
                         Expression *newExpr = choice.expr->clone();
@@ -192 +186 @@
                 // each value of initContext is retained, so the type on the first analysis is preserved and used for selecting
                 // the RHS.
-                ValueGuard<CurrentObject> temp( currentObject );
-                currentObject = CurrentObject( objectDecl->get_type() );
-                if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
+                Type *temp = initContext;
+                initContext = new_type;
+                if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
                         // enumerator initializers should not use the enum type to initialize, since
                         // the enum type is still incomplete at this point. Use signed int instead.
-                        currentObject = CurrentObject( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+                        initContext = new BasicType( Type::Qualifiers(), BasicType::SignedInt );
                 }
                 Parent::visit( objectDecl );
-                if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
+                if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
                         // delete newly created signed int type
-                        // delete currentObject.getType();
-                }
+                        delete initContext;
+                }
+                initContext = temp;
         }
 
@@ -320 +315 @@
 
         void Resolver::visit( SwitchStmt *switchStmt ) {
-                ValueGuard< CurrentObject > oldCurrentObject( currentObject );
+                ValueGuard< Type * > oldInitContext( initContext );
                 Expression *newExpr;
                 newExpr = findIntegralExpression( switchStmt->get_condition(), *this );
@@ -326 +321 @@
                 switchStmt->set_condition( newExpr );
 
-                currentObject = CurrentObject( newExpr->get_result() );
+                initContext = newExpr->get_result();
                 Parent::visit( switchStmt );
         }
@@ -332 +327 @@
         void Resolver::visit( CaseStmt *caseStmt ) {
                 if ( caseStmt->get_condition() ) {
-                        std::list< InitAlternative > initAlts = currentObject.getOptions();
-                        assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral expression." );
-                        CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initAlts.front().type->clone() );
+                        assert( initContext );
+                        CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initContext->clone() );
                         Expression * newExpr = findSingleExpression( castExpr, *this );
                         castExpr = safe_dynamic_cast< CastExpr * >( newExpr );
@@ -376 +370 @@
 
         void Resolver::visit( SingleInit *singleInit ) {
-                // resolve initialization using the possibilities as determined by the currentObject cursor
-                UntypedInitExpr * untyped = new UntypedInitExpr( singleInit->get_value(), currentObject.getOptions() );
-                Expression * newExpr = findSingleExpression( untyped, *this );
-                InitExpr * initExpr = safe_dynamic_cast< InitExpr * >( newExpr );
-
-                // move cursor to the object that is actually initialized
-                currentObject.setNext( initExpr->get_designation() );
-
-                // discard InitExpr wrapper and retain relevant pieces
-                newExpr = initExpr->get_expr();
-                newExpr->set_env( initExpr->get_env() );
-                initExpr->set_expr( nullptr );
-                initExpr->set_env( nullptr );
-                delete initExpr;
-
-                // get the actual object's type (may not exactly match what comes back from the resolver due to conversions)
-                Type * initContext = currentObject.getCurrentType();
-
-                // check if actual object's type is char[]
-                if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
-                        if ( isCharType( at->get_base() ) ) {
-                                // check if the resolved type is char *
-                                if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
-                                        if ( isCharType( pt->get_base() ) ) {
-                                                // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
-                                                CastExpr *ce = safe_dynamic_cast< CastExpr * >( newExpr );
-                                                newExpr = ce->get_arg();
-                                                ce->set_arg( nullptr );
-                                                delete ce;
+                if ( singleInit->get_value() ) {
+                        // // find all the d's
+                        // std::list<Expression *> &designators = singleInit->get_designators();
+                        // std::list<Type *> types1{ initContext }, types2;
+                        // for ( Expression * expr: designators ) {
+                        //      cerr << expr << endl;
+                        //      if ( NameExpr * nexpr = dynamic_cast<NameExpr *>( expr ) ) {
+                        //              for ( Type * type: types1 ) {
+                        //                      cerr << type << endl;
+                        //                      ReferenceToType * fred = dynamic_cast<ReferenceToType *>(type);
+                        //                      std::list<Declaration *> members;
+                        //                      if ( fred ) {
+                        //                              fred->lookup( nexpr->get_name(), members ); // concatenate identical field name
+                        //                              for ( Declaration * mem: members ) {
+                        //                                      if ( DeclarationWithType * dwt = dynamic_cast<DeclarationWithType *>(mem) ) {
+                        //                                              types2.push_back( dwt->get_type() );
+                        //                                      } // if
+                        //                              } // for
+                        //                      } // if
+                        //              } // for
+                        //              types1 = types2;
+                        //              types2.clear();
+                        //      } // if
+                        // } // for
+                        // // for ( Type * type: types1 ) {
+                        // //   cerr << type << endl;
+                        // // } // for
+                        
+                        // // O(N^2) checks of d-types with f-types
+                        // // find the minimum cost
+                        CastExpr *castExpr = new CastExpr( singleInit->get_value(), initContext->clone() );
+                        Expression *newExpr = findSingleExpression( castExpr, *this );
+                        delete castExpr;
+                        singleInit->set_value( newExpr );
+
+                        // check if initializing type is char[]
+                        if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
+                                if ( isCharType( at->get_base() ) ) {
+                                        // check if the resolved type is char *
+                                        if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
+                                                if ( isCharType( pt->get_base() ) ) {
+                                                        // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
+                                                        CastExpr *ce = dynamic_cast< CastExpr * >( newExpr );
+                                                        singleInit->set_value( ce->get_arg() );
+                                                        ce->set_arg( NULL );
+                                                        delete ce;
+                                                }
                                         }
                                 }
                         }
-                }
-
-                // set initializer expr to resolved express
-                singleInit->set_value( newExpr );
-
-                // move cursor to next object in preparation for next initializer
-                currentObject.increment();
+                } // if
+        }
+
+        template< typename AggrInst >
+        TypeSubstitution makeGenericSubstitutuion( AggrInst * inst ) {
+                assert( inst );
+                assert( inst->get_baseParameters() );
+                std::list< TypeDecl * > baseParams = *inst->get_baseParameters();
+                std::list< Expression * > typeSubs = inst->get_parameters();
+                TypeSubstitution subs( baseParams.begin(), baseParams.end(), typeSubs.begin() );
+                return subs;
+        }
+
+        ReferenceToType * isStructOrUnion( Type * type ) {
+                if ( StructInstType * sit = dynamic_cast< StructInstType * >( type ) ) {
+                        return sit;
+                } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( type ) ) {
+                        return uit;
+                }
+                return nullptr;
+        }
+
+        void Resolver::resolveSingleAggrInit( Declaration * dcl, InitIterator & init, InitIterator & initEnd, TypeSubstitution sub ) {
+                DeclarationWithType * dt = dynamic_cast< DeclarationWithType * >( dcl );
+                assert( dt );
+                // need to substitute for generic types, so that casts are to concrete types
+                initContext = dt->get_type()->clone();
+                sub.apply( initContext );
+
+                try {
+                        if ( init == initEnd ) return; // stop when there are no more initializers
+                        (*init)->accept( *this );
+                        ++init; // made it past an initializer
+                } catch( SemanticError & ) {
+                        // need to delve deeper, if you can
+                        if ( ReferenceToType * type = isStructOrUnion( initContext ) ) {
+                                resolveAggrInit( type, init, initEnd );
+                        } else {
+                                // member is not an aggregate type, so can't go any deeper
+
+                                // might need to rethink what is being thrown
+                                throw;
+                        } // if
+                }
+        }
+
+        void Resolver::resolveAggrInit( ReferenceToType * inst, InitIterator & init, InitIterator & initEnd ) {
+                if ( StructInstType * sit = dynamic_cast< StructInstType * >( inst ) ) {
+                        TypeSubstitution sub = makeGenericSubstitutuion( sit );
+                        StructDecl * st = sit->get_baseStruct();
+                        if(st->get_members().empty()) return;
+                        // want to resolve each initializer to the members of the struct,
+                        // but if there are more initializers than members we should stop
+                        list< Declaration * >::iterator it = st->get_members().begin();
+                        for ( ; it != st->get_members().end(); ++it) {
+                                resolveSingleAggrInit( *it, init, initEnd, sub );
+                        }
+                } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( inst ) ) {
+                        TypeSubstitution sub = makeGenericSubstitutuion( uit );
+                        UnionDecl * un = uit->get_baseUnion();
+                        if(un->get_members().empty()) return;
+                        // only resolve to the first member of a union
+                        resolveSingleAggrInit( *un->get_members().begin(), init, initEnd, sub );
+                } // if
         }
 
         void Resolver::visit( ListInit * listInit ) {
-                // move cursor into brace-enclosed initializer-list
-                currentObject.enterListInit();
-                // xxx - fix this so that the list isn't copied, iterator should be used to change current element
-                std::list<Designation *> newDesignations;
-                for ( auto p : group_iterate(listInit->get_designations(), listInit->get_initializers()) ) {
-                        // iterate designations and initializers in pairs, moving the cursor to the current designated object and resolving
-                        // the initializer against that object.
-                        Designation * des = std::get<0>(p);
-                        Initializer * init = std::get<1>(p);
-                        newDesignations.push_back( currentObject.findNext( des ) );
-                        init->accept( *this );
-                }
-                // set the set of 'resolved' designations and leave the brace-enclosed initializer-list
-                listInit->get_designations() = newDesignations; // xxx - memory management
-                currentObject.exitListInit();
-
-                // xxx - this part has not be folded into CurrentObject yet
-                // } else if ( TypeInstType * tt = dynamic_cast< TypeInstType * >( initContext ) ) {
-                //      Type * base = tt->get_baseType()->get_base();
-                //      if ( base ) {
-                //              // know the implementation type, so try using that as the initContext
-                //              ObjectDecl tmpObj( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, base->clone(), nullptr );
-                //              currentObject = &tmpObj;
-                //              visit( listInit );
-                //      } else {
-                //              // missing implementation type -- might be an unknown type variable, so try proceeding with the current init context
-                //              Parent::visit( listInit );
-                //      }
-                // } else {
+                InitIterator iter = listInit->begin();
+                InitIterator end = listInit->end();
+
+                if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
+                        // resolve each member to the base type of the array
+                        for ( ; iter != end; ++iter ) {
+                                initContext = at->get_base();
+                                (*iter)->accept( *this );
+                        } // for
+                } else if ( TupleType * tt = dynamic_cast< TupleType * > ( initContext ) ) {
+                        for ( Type * t : *tt ) {
+                                if ( iter == end ) break;
+                                initContext = t;
+                                (*iter++)->accept( *this );
+                        }
+                } else if ( ReferenceToType * type = isStructOrUnion( initContext ) ) {
+                        resolveAggrInit( type, iter, end );
+                } else if ( TypeInstType * tt = dynamic_cast< TypeInstType * >( initContext ) ) {
+                        Type * base = tt->get_baseType()->get_base();
+                        if ( base ) {
+                                // know the implementation type, so try using that as the initContext
+                                initContext = base;
+                                visit( listInit );
+                        } else {
+                                // missing implementation type -- might be an unknown type variable, so try proceeding with the current init context
+                                Parent::visit( listInit );
+                        }
+                } else {
+                        assert( dynamic_cast< BasicType * >( initContext ) || dynamic_cast< PointerType * >( initContext )
+                                || dynamic_cast< ZeroType * >( initContext ) || dynamic_cast< OneType * >( initContext ) || dynamic_cast < EnumInstType * > ( initContext ) );
+                        // basic types are handled here
+                        Parent::visit( listInit );
+                }
+
+#if 0
+                if ( ArrayType *at = dynamic_cast<ArrayType*>(initContext) ) {
+                        std::list<Initializer *>::iterator iter( listInit->begin_initializers() );
+                        for ( ; iter != listInit->end_initializers(); ++iter ) {
+                                initContext = at->get_base();
+                                (*iter)->accept( *this );
+                        } // for
+                } else if ( StructInstType *st = dynamic_cast<StructInstType*>(initContext) ) {
+                        StructDecl *baseStruct = st->get_baseStruct();
+                        std::list<Declaration *>::iterator iter1( baseStruct->get_members().begin() );
+                        std::list<Initializer *>::iterator iter2( listInit->begin_initializers() );
+                        for ( ; iter1 != baseStruct->get_members().end() && iter2 != listInit->end_initializers(); ++iter2 ) {
+                                if ( (*iter2)->get_designators().empty() ) {
+                                        DeclarationWithType *dt = dynamic_cast<DeclarationWithType *>( *iter1 );
+                                        initContext = dt->get_type();
+                                        (*iter2)->accept( *this );
+                                        ++iter1;
+                                } else {
+                                        StructDecl *st = baseStruct;
+                                        iter1 = st->get_members().begin();
+                                        std::list<Expression *>::iterator iter3( (*iter2)->get_designators().begin() );
+                                        for ( ; iter3 != (*iter2)->get_designators().end(); ++iter3 ) {
+                                                NameExpr *key = dynamic_cast<NameExpr *>( *iter3 );
+                                                assert( key );
+                                                for ( ; iter1 != st->get_members().end(); ++iter1 ) {
+                                                        if ( key->get_name() == (*iter1)->get_name() ) {
+                                                                (*iter1)->print( cout );
+                                                                cout << key->get_name() << endl;
+                                                                ObjectDecl *fred = dynamic_cast<ObjectDecl *>( *iter1 );
+                                                                assert( fred );
+                                                                StructInstType *mary = dynamic_cast<StructInstType*>( fred->get_type() );
+                                                                assert( mary );
+                                                                st = mary->get_baseStruct();
+                                                                iter1 = st->get_members().begin();
+                                                                break;
+                                                        } // if
+                                                }  // for
+                                        } // for
+                                        ObjectDecl *fred = dynamic_cast<ObjectDecl *>( *iter1 );
+                                        assert( fred );
+                                        initContext = fred->get_type();
+                                        (*listInit->begin_initializers())->accept( *this );
+                                } // if
+                        } // for
+                } else if ( UnionInstType *st = dynamic_cast<UnionInstType*>(initContext) ) {
+                        DeclarationWithType *dt = dynamic_cast<DeclarationWithType *>( *st->get_baseUnion()->get_members().begin() );
+                        initContext = dt->get_type();
+                        (*listInit->begin_initializers())->accept( *this );
+                } // if
+#endif
         }