Changeset 62423350 for src/ResolvExpr/Resolver.cc

Timestamp:

Jun 29, 2017, 5:06:24 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:

a12d5aa

Parents:

bb1cd95

Message:

Big push on designations and initialization: works with generic types, tuples, arrays, tests pass.
Refactor guard_value_impl.
Add list of declarations to TupleType?.

File:

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

src/ResolvExpr/Resolver.cc

@@ -375 +375 @@
         }
 
-        template< typename Aggr >
-        void lookupDesignation( Aggr * aggr, const std::list< Expression > & designators ) {
-
-        }
-
         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 );
-                singleInit->set_value( new CastExpr( initExpr->get_expr()->clone(), initExpr->get_result()->clone() ) );
+
+                // 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();
+                singleInit->get_value()->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;
+                                        }
+                                }
+                        }
+                }
+
+                // set initializer expr to resolved express
+                singleInit->set_value( newExpr );
+
+                // move cursor to next object in preparation for next initializer
                 currentObject.increment();
-                delete initExpr;
-
-                // // 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;
-                //                      }
-                //              }
-                //      }
-                // }
-        }
-
-        // template< typename AggrInst >
-        // TypeSubstitution makeGenericSubstitution( 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 ) {
-        //      ObjectDecl * obj = dynamic_cast< ObjectDecl * >( dcl );
-        //      assert( obj );
-        //      // need to substitute for generic types, so that casts are to concrete types
-        //      currentObject = obj->clone();  // xxx - delete this
-        //      sub.apply( currentObject );
-
-        //      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( currentObject->get_type() ) ) {
-        //                      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 = makeGenericSubstitution( 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 = makeGenericSubstitution( 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);
@@ -479 +430 @@
                         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();