Changeset 60aaa51d for src/ResolvExpr/Resolver.cc

Timestamp:

Jun 7, 2019, 4:14:48 PM (5 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

05d55ff

Parents:

5684736

git-author:

Aaron Moss <a3moss@…> (06/07/19 16:14:40)

git-committer:

Aaron Moss <a3moss@…> (06/07/19 16:14:48)

Message:

More resolver porting; mostly CurrentObject?

File:

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

src/ResolvExpr/Resolver.cc

@@ -781 +781 @@
         }
 
-        template< typename T >
-        bool isCharType( T t ) {
+        bool isCharType( Type * t ) {
                 if ( BasicType * bt = dynamic_cast< BasicType * >( t ) ) {
                         return bt->get_kind() == BasicType::Char || bt->get_kind() == BasicType::SignedChar ||
@@ -1071 +1070 @@
                 };
 
+                /// Swaps argument into expression pointer, saving original environment
+                void swap_and_save_env( ast::ptr< ast::Expr > & expr, const ast::Expr * newExpr ) {
+                        ast::ptr< ast::TypeSubstitution > env = expr->env;
+                        expr.set_and_mutate( newExpr )->env = env;
+                }
+
                 /// Removes cast to type of argument (unlike StripCasts, also handles non-generated casts)
                 void removeExtraneousCast( ast::ptr<ast::Expr> & expr, const ast::SymbolTable & symtab ) {
@@ -1076 +1081 @@
                                 if ( typesCompatible( castExpr->arg->result, castExpr->result, symtab ) ) {
                                         // cast is to the same type as its argument, remove it
-                                        ast::ptr< ast::TypeSubstitution > env = castExpr->env;
-                                        expr.set_and_mutate( castExpr->arg )->env = env;
+                                        swap_and_save_env( expr, castExpr->arg );
                                 }
                         }
@@ -1175 +1179 @@
                         return findKindExpression( untyped, symtab, hasIntegralType, "condition" );
                 }
+
+                /// check if a type is a character type
+                bool isCharType( const ast::Type * t ) {
+                        if ( auto bt = dynamic_cast< const ast::BasicType * >( t ) ) {
+                                return bt->kind == ast::BasicType::Char 
+                                        || bt->kind == ast::BasicType::SignedChar 
+                                        || bt->kind == ast::BasicType::UnsignedChar;
+                        }
+                        return false;
+                }
         }
 
@@ -1213 +1227 @@
                 void previsit( const ast::WaitForStmt * );
 
-                void previsit( const ast::SingleInit * );
-                void previsit( const ast::ListInit * );
+                const ast::SingleInit * previsit( const ast::SingleInit * );
+                const ast::ListInit * previsit( const ast::ListInit * );
                 void previsit( const ast::ConstructorInit * );
         };
@@ -1363 +1377 @@
         const ast::CaseStmt * Resolver_new::previsit( const ast::CaseStmt * caseStmt ) {
                 if ( caseStmt->cond ) {
-                        std::vector< ast::InitAlternative > initAlts = currentObject.getOptions();
+                        std::deque< ast::InitAlternative > initAlts = currentObject.getOptions();
                         assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral "
                                 "expression." );
@@ -1374 +1388 @@
                         // whether it would perform a conversion.
                         if ( const ast::CastExpr * castExpr = newExpr.as< ast::CastExpr >() ) {
-                                ast::ptr< ast::TypeSubstitution > env = castExpr->env;
-                                newExpr.set_and_mutate( castExpr->arg )->env = env;
+                                swap_and_save_env( newExpr, castExpr->arg );
                         }
                         
@@ -1438 +1451 @@
         }
 
-        void Resolver_new::previsit( const ast::SingleInit * singleInit ) {
-                #warning unimplemented; Resolver port in progress
-                (void)singleInit;
-                assert(false);
-        }
-
-        void Resolver_new::previsit( const ast::ListInit * listInit ) {
-                #warning unimplemented; Resolver port in progress
-                (void)listInit;
-                assert(false);
+
+
+        const ast::SingleInit * Resolver_new::previsit( const ast::SingleInit * singleInit ) {
+                visit_children = false;
+                // resolve initialization using the possibilities as determined by the `currentObject` 
+                // cursor.
+                ast::Expr * untyped = new ast::UntypedInitExpr{ 
+                        singleInit->location, singleInit->value, currentObject.getOptions() };
+                ast::ptr<ast::Expr> newExpr = findKindExpression( untyped, symtab );
+                const ast::InitExpr * initExpr = newExpr.strict_as< ast::InitExpr >();
+
+                // move cursor to the object that is actually initialized
+                currentObject.setNext( initExpr->designation );
+
+                // discard InitExpr wrapper and retain relevant pieces.
+                // `initExpr` may have inferred params in the case where the expression specialized a 
+                // function pointer, and newExpr may already have inferParams of its own, so a simple 
+                // swap is not sufficient
+                ast::Expr::InferUnion inferred = initExpr->inferred;
+                swap_and_save_env( newExpr, initExpr->expr );
+                newExpr.get_and_mutate()->inferred.splice( std::move(inferred) );
+
+                // get the actual object's type (may not exactly match what comes back from the resolver 
+                // due to conversions)
+                const ast::Type * initContext = currentObject.getCurrentType();
+
+                removeExtraneousCast( newExpr, symtab );
+
+                // check if actual object's type is char[]
+                if ( auto at = dynamic_cast< const ast::ArrayType * >( initContext ) ) {
+                        if ( isCharType( at->base ) ) {
+                                // check if the resolved type is char*
+                                if ( auto pt = newExpr->result.as< ast::PointerType >() ) {
+                                        if ( isCharType( pt->base ) ) {
+                                                // strip cast if we're initializing a char[] with a char* 
+                                                // e.g. char x[] = "hello"
+                                                if ( auto ce = newExpr.as< ast::CastExpr >() ) {
+                                                        swap_and_save_env( newExpr, ce->arg );
+                                                }
+                                        }
+                                }
+                        }
+                }
+
+                // move cursor to next object in preparation for next initializer
+                currentObject.increment();
+
+                // set initializer expression to resolved expression
+                return ast::mutate_field( singleInit, &ast::SingleInit::value, std::move(newExpr) );
+        }
+
+        const ast::ListInit * Resolver_new::previsit( const ast::ListInit * listInit ) {
+                // move cursor into brace-enclosed initializer-list
+                currentObject.enterListInit( listInit->location );
+
+                assert( listInit->designations.size() == listInit->initializers.size() );
+                for ( unsigned i = 0; i < listInit->designations.size(); ++i ) {
+                        // iterate designations and initializers in pairs, moving the cursor to the current 
+                        // designated object and resolving the initializer against that object
+                        #warning unimplemented; Resolver port in progress
+                        assert(false);
+                }
+
+                visit_children = false;
+                return listInit;
         }