Changeset 6949c45 for src/ResolvExpr/CurrentObject.cc

Timestamp:

Jun 10, 2019, 1:51:24 PM (5 years ago)

Author:

Peter A. Buhr <pabuhr@…>

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:

2773ab8, 558d13b

Parents:

891b827 (diff), f9a7cf0 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/ResolvExpr/CurrentObject.cc (modified) (1 diff)

src/ResolvExpr/CurrentObject.cc

@@ -946 +946 @@
         }
 
-        void CurrentObject::setNext( const ast::Designation * designation ) {
+        const Designation * CurrentObject::findNext( const Designation * designation ) {
+                using DesignatorChain = std::deque< ptr< Expr > >;
+                PRINT( std::cerr << "___findNext" << std::endl; )
+                
+                // find all the d's
+                std::vector< DesignatorChain > desigAlts{ {} }, newDesigAlts;
+                std::deque< const Type * > curTypes{ objStack.back()->getType() }, newTypes;
+                for ( const Expr * expr : designation->designators ) {
+                        PRINT( std::cerr << "____untyped: " << expr << std::endl; )
+                        auto dit = desigAlts.begin();
+                        if ( auto nexpr = dynamic_cast< const NameExpr * >( expr ) ) {
+                                for ( const Type * t : curTypes ) {
+                                        assert( dit != desigAlts.end() );
+
+                                        DesignatorChain & d = *dit;
+                                        PRINT( std::cerr << "____actual: " << t << std::endl; )
+                                        if ( auto refType = dynamic_cast< const ReferenceToType * >( t ) ) {
+                                                // concatenate identical field names
+                                                for ( const Decl * mem : refType->lookup( nexpr->name ) ) {
+                                                        if ( auto field = dynamic_cast< const ObjectDecl * >( mem ) ) {
+                                                                PRINT( std::cerr << "____alt: " << field->type << std::endl; )
+                                                                DesignatorChain d2 = d;
+                                                                d2.emplace_back( new VariableExpr{ expr->location, field } );
+                                                                newDesigAlts.emplace_back( std::move( d2 ) );
+                                                                newTypes.emplace_back( field->type );
+                                                        }
+                                                }
+                                        }
+
+                                        ++dit;
+                                }
+                        } else {
+                                for ( const Type * t : curTypes ) {
+                                        assert( dit != desigAlts.end() );
+
+                                        DesignatorChain & d = *dit;
+                                        if ( auto at = dynamic_cast< const ArrayType * >( t ) ) {
+                                                PRINT( std::cerr << "____alt: " << at->get_base() << std::endl; )
+                                                d.emplace_back( expr );
+                                                newDesigAlts.emplace_back( d );
+                                                newTypes.emplace_back( at->base );
+                                        }
+                                }
+                        }
+
+                        // reset queue
+                        desigAlts = std::move( newDesigAlts );
+                        newDesigAlts.clear();
+                        curTypes = std::move( newTypes );
+                        newTypes.clear();
+                        assertf( desigAlts.size() == curTypes.size(), "Designator alternatives (%zu) and current types (%zu) out of sync", desigAlts.size(), curTypes.size() );
+                }
+
+                if ( desigAlts.size() > 1 ) {
+                        SemanticError( designation, toString("Too many alternatives (", desigAlts.size(), ") for designation: ") );
+                } else if ( desigAlts.empty() ) {
+                        SemanticError( designation, "No reasonable alternatives for designation: " );
+                }
+
+                DesignatorChain & d = desigAlts.back();
+                PRINT( for ( Expression * expr : d ) {
+                        std::cerr << "____desig: " << expr << std::endl;
+                } ) // for
+                assertf( ! curTypes.empty(), "empty designator chosen");
+
+                // set new designators
+                assertf( ! objStack.empty(), "empty object stack when setting designation" );
+                Designation * actualDesignation = 
+                        new Designation{ designation->location, DesignatorChain{d} };
+                objStack.back()->setPosition( d ); // destroys d
+                return actualDesignation;
+        }
+
+        void CurrentObject::setNext( const Designation * designation ) {
                 PRINT( std::cerr << "____setNext" << designation << std::endl; )
                 assertf( ! objStack.empty(), "obj stack empty in setNext" );