Index: src/CodeGen/CodeGenerator.cc =================================================================== --- src/CodeGen/CodeGenerator.cc (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/CodeGen/CodeGenerator.cc (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -288,16 +288,16 @@ } - void CodeGenerator::printDesignators( std::list< Expression * > & designators ) { - typedef std::list< Expression * > DesignatorList; + void CodeGenerator::visit( Designation * designation ) { + std::list< Expression * > designators = designation->get_designators(); if ( designators.size() == 0 ) return; - for ( DesignatorList::iterator iter = designators.begin(); iter != designators.end(); ++iter ) { - if ( dynamic_cast< NameExpr * >( *iter ) ) { - // if expression is a name, then initializing aggregate member + for ( Expression * des : designators ) { + if ( dynamic_cast< NameExpr * >( des ) || dynamic_cast< VariableExpr * >( des ) ) { + // if expression is a NameExpr or VariableExpr, then initializing aggregate member output << "."; - (*iter)->accept( *this ); + des->accept( *this ); } else { - // if not a simple name, it has to be a constant expression, i.e. an array designator + // otherwise, it has to be a ConstantExpr or CastExpr, initializing array eleemnt output << "["; - (*iter)->accept( *this ); + des->accept( *this ); output << "]"; } // if @@ -307,13 +307,24 @@ void CodeGenerator::visit( SingleInit * init ) { - printDesignators( init->get_designators() ); init->get_value()->accept( *this ); } void CodeGenerator::visit( ListInit * init ) { - printDesignators( init->get_designators() ); + auto initBegin = init->begin(); + auto initEnd = init->end(); + auto desigBegin = init->get_designations().begin(); + auto desigEnd = init->get_designations().end(); + output << "{ "; - genCommaList( init->begin(), init->end() ); + for ( ; initBegin != initEnd && desigBegin != desigEnd; ) { + (*desigBegin)->accept( *this ); + (*initBegin)->accept( *this ); + ++initBegin, ++desigBegin; + if ( initBegin != initEnd ) { + output << ", "; + } + } output << " }"; + assertf( initBegin == initEnd && desigBegin == desigEnd, "Initializers and designators not the same length. %s", toString( init ).c_str() ); } @@ -716,6 +727,9 @@ void CodeGenerator::visit( TypeExpr * typeExpr ) { - assertf( ! genC, "TypeExpr should not reach code generation." ); - output<< genType( typeExpr->get_type(), "", pretty, genC ); + // if ( genC ) std::cerr << "typeexpr still exists: " << typeExpr << std::endl; + // assertf( ! genC, "TypeExpr should not reach code generation." ); + if ( ! genC ) { + output<< genType( typeExpr->get_type(), "", pretty, genC ); + } } Index: src/CodeGen/CodeGenerator.h =================================================================== --- src/CodeGen/CodeGenerator.h (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/CodeGen/CodeGenerator.h (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -47,4 +47,5 @@ //*** Initializer + virtual void visit( Designation * ); virtual void visit( SingleInit * ); virtual void visit( ListInit * ); @@ -137,5 +138,4 @@ bool lineMarks = false; - void printDesignators( std::list< Expression * > & ); void handleStorageClass( DeclarationWithType *decl ); void handleAggregate( AggregateDecl *aggDecl, const std::string & kind ); Index: src/Common/PassVisitor.h =================================================================== --- src/Common/PassVisitor.h (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/Common/PassVisitor.h (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -257,15 +257,4 @@ void set_visit_children( bool& ref ) { bool_ref * ptr = visit_children_impl(pass, 0); if(ptr) ptr->set( ref ); } - - guard_value_impl init_guard() { - guard_value_impl guard; - auto at_cleanup = at_cleanup_impl(pass, 0); - if( at_cleanup ) { - *at_cleanup = [&guard]( cleanup_func_t && func, void* val ) { - guard.push( std::move( func ), val ); - }; - } - return guard; - } }; Index: src/Common/PassVisitor.impl.h =================================================================== --- src/Common/PassVisitor.impl.h (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/Common/PassVisitor.impl.h (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -3,5 +3,5 @@ #define VISIT_START( node ) \ __attribute__((unused)) \ - const auto & guard = init_guard(); \ + guard_value_impl guard( at_cleanup_impl(pass, 0) ); \ bool visit_children = true; \ set_visit_children( visit_children ); \ @@ -15,5 +15,5 @@ #define MUTATE_START( node ) \ __attribute__((unused)) \ - const auto & guard = init_guard(); \ + guard_value_impl guard( at_cleanup_impl(pass, 0) ); \ bool visit_children = true; \ set_visit_children( visit_children ); \ Index: src/Common/PassVisitor.proto.h =================================================================== --- src/Common/PassVisitor.proto.h (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/Common/PassVisitor.proto.h (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -5,8 +5,15 @@ typedef std::function cleanup_func_t; +typedef std::function< void( cleanup_func_t, void * ) > at_cleanup_t; class guard_value_impl { public: - guard_value_impl() = default; + guard_value_impl( at_cleanup_t * at_cleanup ) { + if( at_cleanup ) { + *at_cleanup = [this]( cleanup_func_t && func, void* val ) { + push( std::move( func ), val ); + }; + } + } ~guard_value_impl() { @@ -33,5 +40,4 @@ }; -typedef std::function< void( cleanup_func_t, void * ) > at_cleanup_t; class bool_ref { Index: src/Common/utility.h =================================================================== --- src/Common/utility.h (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/Common/utility.h (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -305,5 +305,5 @@ // for ( val : group_iterate( container1, container2, ... ) ) {} // syntax to have a for each that iterates multiple containers of the same length -// TODO: update to use variadic arguments +// TODO: update to use variadic arguments, perfect forwarding template< typename T1, typename T2 > Index: src/InitTweak/FixInit.cc =================================================================== --- src/InitTweak/FixInit.cc (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/InitTweak/FixInit.cc (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -104,5 +104,6 @@ typedef AddStmtVisitor Parent; using Parent::visit; - typedef std::set< ObjectDecl * > ObjectSet; + // use ordered data structure to maintain ordering for set_difference and for consistent error messages + typedef std::list< ObjectDecl * > ObjectSet; virtual void visit( CompoundStmt *compoundStmt ) override; virtual void visit( DeclStmt *stmt ) override; @@ -116,10 +117,13 @@ // debug - struct printSet { - typedef ObjDeclCollector::ObjectSet ObjectSet; - printSet( const ObjectSet & objs ) : objs( objs ) {} + template + struct PrintSet { + PrintSet( const ObjectSet & objs ) : objs( objs ) {} const ObjectSet & objs; }; - std::ostream & operator<<( std::ostream & out, const printSet & set) { + template + PrintSet printSet( const ObjectSet & objs ) { return PrintSet( objs ); } + template + std::ostream & operator<<( std::ostream & out, const PrintSet & set) { out << "{ "; for ( ObjectDecl * obj : set.objs ) { @@ -724,5 +728,5 @@ // static bool __objName_uninitialized = true BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool ); - SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant::from_int( 1 ) ), noDesignators ); + SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant::from_int( 1 ) ) ); ObjectDecl * isUninitializedVar = new ObjectDecl( objDecl->get_mangleName() + "_uninitialized", Type::StorageClasses( Type::Static ), LinkageSpec::Cforall, 0, boolType, boolInitExpr ); isUninitializedVar->fixUniqueId(); @@ -745,6 +749,6 @@ Statement * dtor = ctorInit->get_dtor(); - objDecl->set_init( NULL ); - ctorInit->set_ctor( NULL ); + objDecl->set_init( nullptr ); + ctorInit->set_ctor( nullptr ); ctorInit->set_dtor( nullptr ); if ( dtor ) { @@ -799,14 +803,14 @@ } else { stmtsToAddAfter.push_back( ctor ); - objDecl->set_init( NULL ); - ctorInit->set_ctor( NULL ); + objDecl->set_init( nullptr ); + ctorInit->set_ctor( nullptr ); } } // if } else if ( Initializer * init = ctorInit->get_init() ) { objDecl->set_init( init ); - ctorInit->set_init( NULL ); + ctorInit->set_init( nullptr ); } else { // no constructor and no initializer, which is okay - objDecl->set_init( NULL ); + objDecl->set_init( nullptr ); } // if delete ctorInit; @@ -816,5 +820,5 @@ void ObjDeclCollector::visit( CompoundStmt * compoundStmt ) { - std::set< ObjectDecl * > prevVars = curVars; + ObjectSet prevVars = curVars; Parent::visit( compoundStmt ); curVars = prevVars; @@ -824,5 +828,5 @@ // keep track of all variables currently in scope if ( ObjectDecl * objDecl = dynamic_cast< ObjectDecl * > ( stmt->get_decl() ) ) { - curVars.insert( objDecl ); + curVars.push_back( objDecl ); } // if Parent::visit( stmt ); @@ -939,9 +943,12 @@ ) if ( ! diff.empty() ) { + // create an auxilliary set for fast lookup -- can't make diff a set, because diff ordering should be consistent for error messages. + std::unordered_set needsDestructor( diff.begin(), diff.end() ); + // go through decl ordered list of objectdecl. for each element that occurs in diff, output destructor OrderedDecls ordered; for ( OrderedDecls & rdo : reverseDeclOrder ) { // add elements from reverseDeclOrder into ordered if they occur in diff - it is key that this happens in reverse declaration order. - copy_if( rdo.begin(), rdo.end(), back_inserter( ordered ), [&]( ObjectDecl * objDecl ) { return diff.count( objDecl ); } ); + copy_if( rdo.begin(), rdo.end(), back_inserter( ordered ), [&]( ObjectDecl * objDecl ) { return needsDestructor.count( objDecl ); } ); } // for insertDtors( ordered.begin(), ordered.end(), back_inserter( stmtsToAdd ) ); Index: src/InitTweak/InitTweak.cc =================================================================== --- src/InitTweak/InitTweak.cc (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/InitTweak/InitTweak.cc (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -14,11 +14,8 @@ public: bool hasDesignations = false; - template - void handleInit( Init * init ) { - if ( ! init->get_designators().empty() ) hasDesignations = true; - else Visitor::visit( init ); - } - virtual void visit( SingleInit * singleInit ) { handleInit( singleInit); } - virtual void visit( ListInit * listInit ) { handleInit( listInit); } + virtual void visit( Designation * des ) { + if ( ! des->get_designators().empty() ) hasDesignations = true; + else Visitor::visit( des ); + } }; Index: src/MakeLibCfa.cc =================================================================== --- src/MakeLibCfa.cc (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/MakeLibCfa.cc (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -92,5 +92,5 @@ assert( ! objDecl->get_init() ); std::list< Expression* > noDesignators; - objDecl->set_init( new SingleInit( new NameExpr( objDecl->get_name() ), noDesignators, false ) ); // cannot be constructed + objDecl->set_init( new SingleInit( new NameExpr( objDecl->get_name() ), false ) ); // cannot be constructed newDecls.push_back( objDecl ); } Index: src/Makefile.in =================================================================== --- src/Makefile.in (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/Makefile.in (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -162,4 +162,5 @@ ResolvExpr/driver_cfa_cpp-Occurs.$(OBJEXT) \ ResolvExpr/driver_cfa_cpp-TypeEnvironment.$(OBJEXT) \ + ResolvExpr/driver_cfa_cpp-CurrentObject.$(OBJEXT) \ SymTab/driver_cfa_cpp-Indexer.$(OBJEXT) \ SymTab/driver_cfa_cpp-Mangler.$(OBJEXT) \ @@ -416,12 +417,12 @@ ResolvExpr/RenameVars.cc ResolvExpr/FindOpenVars.cc \ ResolvExpr/PolyCost.cc ResolvExpr/Occurs.cc \ - ResolvExpr/TypeEnvironment.cc SymTab/Indexer.cc \ - SymTab/Mangler.cc SymTab/Validate.cc SymTab/FixFunction.cc \ - SymTab/ImplementationType.cc SymTab/TypeEquality.cc \ - SymTab/Autogen.cc SynTree/Type.cc SynTree/VoidType.cc \ - SynTree/BasicType.cc SynTree/PointerType.cc \ - SynTree/ArrayType.cc SynTree/FunctionType.cc \ - SynTree/ReferenceToType.cc SynTree/TupleType.cc \ - SynTree/TypeofType.cc SynTree/AttrType.cc \ + ResolvExpr/TypeEnvironment.cc ResolvExpr/CurrentObject.cc \ + SymTab/Indexer.cc SymTab/Mangler.cc SymTab/Validate.cc \ + SymTab/FixFunction.cc SymTab/ImplementationType.cc \ + SymTab/TypeEquality.cc SymTab/Autogen.cc SynTree/Type.cc \ + SynTree/VoidType.cc SynTree/BasicType.cc \ + SynTree/PointerType.cc SynTree/ArrayType.cc \ + SynTree/FunctionType.cc SynTree/ReferenceToType.cc \ + SynTree/TupleType.cc SynTree/TypeofType.cc SynTree/AttrType.cc \ SynTree/VarArgsType.cc SynTree/ZeroOneType.cc \ SynTree/Constant.cc SynTree/Expression.cc SynTree/TupleExpr.cc \ @@ -726,4 +727,7 @@ ResolvExpr/$(am__dirstamp) \ ResolvExpr/$(DEPDIR)/$(am__dirstamp) +ResolvExpr/driver_cfa_cpp-CurrentObject.$(OBJEXT): \ + ResolvExpr/$(am__dirstamp) \ + ResolvExpr/$(DEPDIR)/$(am__dirstamp) SymTab/$(am__dirstamp): @$(MKDIR_P) SymTab @@ -896,4 +900,5 @@ -rm -f ResolvExpr/driver_cfa_cpp-CommonType.$(OBJEXT) -rm -f ResolvExpr/driver_cfa_cpp-ConversionCost.$(OBJEXT) + -rm -f ResolvExpr/driver_cfa_cpp-CurrentObject.$(OBJEXT) -rm -f ResolvExpr/driver_cfa_cpp-FindOpenVars.$(OBJEXT) -rm -f ResolvExpr/driver_cfa_cpp-Occurs.$(OBJEXT) @@ -1009,4 +1014,5 @@ @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CommonType.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-ConversionCost.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-FindOpenVars.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-Occurs.Po@am__quote@ @@ -1964,4 +1970,18 @@ @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ResolvExpr/driver_cfa_cpp-TypeEnvironment.obj `if test -f 'ResolvExpr/TypeEnvironment.cc'; then $(CYGPATH_W) 'ResolvExpr/TypeEnvironment.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/TypeEnvironment.cc'; fi` +ResolvExpr/driver_cfa_cpp-CurrentObject.o: ResolvExpr/CurrentObject.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ResolvExpr/driver_cfa_cpp-CurrentObject.o -MD -MP -MF ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Tpo -c -o ResolvExpr/driver_cfa_cpp-CurrentObject.o `test -f 'ResolvExpr/CurrentObject.cc' || echo '$(srcdir)/'`ResolvExpr/CurrentObject.cc +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Tpo ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='ResolvExpr/CurrentObject.cc' object='ResolvExpr/driver_cfa_cpp-CurrentObject.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ResolvExpr/driver_cfa_cpp-CurrentObject.o `test -f 'ResolvExpr/CurrentObject.cc' || echo '$(srcdir)/'`ResolvExpr/CurrentObject.cc + +ResolvExpr/driver_cfa_cpp-CurrentObject.obj: ResolvExpr/CurrentObject.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ResolvExpr/driver_cfa_cpp-CurrentObject.obj -MD -MP -MF ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Tpo -c -o ResolvExpr/driver_cfa_cpp-CurrentObject.obj `if test -f 'ResolvExpr/CurrentObject.cc'; then $(CYGPATH_W) 'ResolvExpr/CurrentObject.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/CurrentObject.cc'; fi` +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Tpo ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='ResolvExpr/CurrentObject.cc' object='ResolvExpr/driver_cfa_cpp-CurrentObject.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ResolvExpr/driver_cfa_cpp-CurrentObject.obj `if test -f 'ResolvExpr/CurrentObject.cc'; then $(CYGPATH_W) 'ResolvExpr/CurrentObject.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/CurrentObject.cc'; fi` + SymTab/driver_cfa_cpp-Indexer.o: SymTab/Indexer.cc @am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SymTab/driver_cfa_cpp-Indexer.o -MD -MP -MF SymTab/$(DEPDIR)/driver_cfa_cpp-Indexer.Tpo -c -o SymTab/driver_cfa_cpp-Indexer.o `test -f 'SymTab/Indexer.cc' || echo '$(srcdir)/'`SymTab/Indexer.cc Index: src/Parser/InitializerNode.cc =================================================================== --- src/Parser/InitializerNode.cc (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/Parser/InitializerNode.cc (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -74,30 +74,27 @@ InitializerNode *moreInit; - if ( get_next() != 0 && ((moreInit = dynamic_cast< InitializerNode * >( get_next() ) ) != 0) ) + if ( (moreInit = dynamic_cast< InitializerNode * >( get_next() ) ) ) { moreInit->printOneLine( os ); + } } Initializer *InitializerNode::build() const { if ( aggregate ) { + // steal designators from children + std::list< Designation * > designlist; + InitializerNode * child = next_init(); + for ( ; child != nullptr; child = dynamic_cast< InitializerNode * >( child->get_next() ) ) { + std::list< Expression * > desList; + buildList< Expression, ExpressionNode >( child->designator, desList ); + designlist.push_back( new Designation( desList ) ); + } // for std::list< Initializer * > initlist; buildList< Initializer, InitializerNode >( next_init(), initlist ); - - std::list< Expression * > designlist; - - if ( designator != 0 ) { - buildList< Expression, ExpressionNode >( designator, designlist ); - } // if - return new ListInit( initlist, designlist, maybeConstructed ); } else { - std::list< Expression * > designators; - - if ( designator != 0 ) - buildList< Expression, ExpressionNode >( designator, designators ); - - if ( get_expression() != 0) - return new SingleInit( maybeBuild< Expression >( get_expression() ), designators, maybeConstructed ); + if ( get_expression() != 0) { + return new SingleInit( maybeBuild< Expression >( get_expression() ), maybeConstructed ); + } } // if - return 0; } Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/Parser/TypeData.cc (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -760,5 +760,5 @@ if ( cur->has_enumeratorValue() ) { ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members); - member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ), list< Expression * >() ) ); + member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ) ) ); } // if } // for @@ -777,6 +777,7 @@ TupleType * buildTuple( const TypeData * td ) { assert( td->kind == TypeData::Tuple ); - TupleType * ret = new TupleType( buildQualifiers( td ) ); - buildTypeList( td->tuple, ret->get_types() ); + std::list< Type * > types; + buildTypeList( td->tuple, types ); + TupleType * ret = new TupleType( buildQualifiers( td ), types ); buildForall( td->forall, ret->get_forall() ); return ret; Index: src/ResolvExpr/AlternativeFinder.cc =================================================================== --- src/ResolvExpr/AlternativeFinder.cc (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/ResolvExpr/AlternativeFinder.cc (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -604,10 +604,10 @@ // ) SymTab::Indexer decls( indexer ); - PRINT( - std::cerr << "============= original indexer" << std::endl; - indexer.print( std::cerr ); - std::cerr << "============= new indexer" << std::endl; - decls.print( std::cerr ); - ) + // PRINT( + // std::cerr << "============= original indexer" << std::endl; + // indexer.print( std::cerr ); + // std::cerr << "============= new indexer" << std::endl; + // decls.print( std::cerr ); + // ) addToIndexer( have, decls ); AssertionSet newNeed; @@ -809,4 +809,30 @@ } + Expression * restructureCast( Expression * argExpr, Type * toType ) { + if ( argExpr->get_result()->size() > 1 && ! toType->isVoid() ) { + // Argument expression is a tuple and the target type is not void. Cast each member of the tuple + // to its corresponding target type, producing the tuple of those cast expressions. If there are + // more components of the tuple than components in the target type, then excess components do not + // come out in the result expression (but UniqueExprs ensure that side effects will still be done). + if ( Tuples::maybeImpure( argExpr ) && ! dynamic_cast< UniqueExpr * >( argExpr ) ) { + // expressions which may contain side effects require a single unique instance of the expression. + argExpr = new UniqueExpr( argExpr ); + } + std::list< Expression * > componentExprs; + for ( unsigned int i = 0; i < toType->size(); i++ ) { + // cast each component + TupleIndexExpr * idx = new TupleIndexExpr( argExpr->clone(), i ); + componentExprs.push_back( restructureCast( idx, toType->getComponent( i ) ) ); + } + delete argExpr; + assert( componentExprs.size() > 0 ); + // produce the tuple of casts + return new TupleExpr( componentExprs ); + } else { + // handle normally + return new CastExpr( argExpr, toType->clone() ); + } + } + void AlternativeFinder::visit( CastExpr *castExpr ) { Type *& toType = castExpr->get_result(); @@ -840,28 +866,5 @@ thisCost += Cost( 0, 0, discardedValues ); - Expression * argExpr = i->expr->clone(); - if ( argExpr->get_result()->size() > 1 && ! castExpr->get_result()->isVoid() ) { - // Argument expression is a tuple and the target type is not void. Cast each member of the tuple - // to its corresponding target type, producing the tuple of those cast expressions. If there are - // more components of the tuple than components in the target type, then excess components do not - // come out in the result expression (but UniqueExprs ensure that side effects will still be done). - if ( Tuples::maybeImpure( argExpr ) && ! dynamic_cast< UniqueExpr * >( argExpr ) ) { - // expressions which may contain side effects require a single unique instance of the expression. - argExpr = new UniqueExpr( argExpr ); - } - std::list< Expression * > componentExprs; - for ( unsigned int i = 0; i < castExpr->get_result()->size(); i++ ) { - // cast each component - TupleIndexExpr * idx = new TupleIndexExpr( argExpr->clone(), i ); - componentExprs.push_back( new CastExpr( idx, castExpr->get_result()->getComponent( i )->clone() ) ); - } - delete argExpr; - assert( componentExprs.size() > 0 ); - // produce the tuple of casts - candidates.push_back( Alternative( new TupleExpr( componentExprs ), i->env, i->cost, thisCost ) ); - } else { - // handle normally - candidates.push_back( Alternative( new CastExpr( argExpr->clone(), toType->clone() ), i->env, i->cost, thisCost ) ); - } + candidates.push_back( Alternative( restructureCast( i->expr->clone(), toType ), i->env, i->cost, thisCost ) ); } // if } // for @@ -1182,4 +1185,51 @@ } + void AlternativeFinder::visit( UntypedInitExpr *initExpr ) { + // handle each option like a cast + AltList candidates; + PRINT( std::cerr << "untyped init expr: " << initExpr << std::endl; ) + // O(N^2) checks of d-types with e-types + for ( InitAlternative & initAlt : initExpr->get_initAlts() ) { + Type * toType = resolveTypeof( initAlt.type, indexer ); + SymTab::validateType( toType, &indexer ); + adjustExprType( toType, env, indexer ); + // Ideally the call to findWithAdjustment could be moved out of the loop, but unfortunately it currently has to occur inside or else + // polymorphic return types are not properly bound to the initialization type, since return type variables are only open for the duration of resolving + // the UntypedExpr. This is only actually an issue in initialization contexts that allow more than one possible initialization type, but it is still suboptimal. + AlternativeFinder finder( indexer, env ); + finder.targetType = toType; + finder.findWithAdjustment( initExpr->get_expr() ); + for ( Alternative & alt : finder.get_alternatives() ) { + TypeEnvironment newEnv( alt.env ); + AssertionSet needAssertions, haveAssertions; + OpenVarSet openVars; // find things in env that don't have a "representative type" and claim those are open vars? + PRINT( std::cerr << " @ " << toType << " " << initAlt.designation << std::endl; ) + // It's possible that a cast can throw away some values in a multiply-valued expression. (An example is a + // cast-to-void, which casts from one value to zero.) Figure out the prefix of the subexpression results + // that are cast directly. The candidate is invalid if it has fewer results than there are types to cast + // to. + int discardedValues = alt.expr->get_result()->size() - toType->size(); + if ( discardedValues < 0 ) continue; + // xxx - may need to go into tuple types and extract relevant types and use unifyList. Note that currently, this does not + // allow casting a tuple to an atomic type (e.g. (int)([1, 2, 3])) + // unification run for side-effects + unify( toType, alt.expr->get_result(), newEnv, needAssertions, haveAssertions, openVars, indexer ); // xxx - do some inspecting on this line... why isn't result bound to initAlt.type?? + + Cost thisCost = castCost( alt.expr->get_result(), toType, indexer, newEnv ); + if ( thisCost != Cost::infinity ) { + // count one safe conversion for each value that is thrown away + thisCost += Cost( 0, 0, discardedValues ); + candidates.push_back( Alternative( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost ) ); + } + } + } + + // findMinCost selects the alternatives with the lowest "cost" members, but has the side effect of copying the + // cvtCost member to the cost member (since the old cost is now irrelevant). Thus, calling findMinCost twice + // selects first based on argument cost, then on conversion cost. + AltList minArgCost; + findMinCost( candidates.begin(), candidates.end(), std::back_inserter( minArgCost ) ); + findMinCost( minArgCost.begin(), minArgCost.end(), std::back_inserter( alternatives ) ); + } } // namespace ResolvExpr Index: src/ResolvExpr/AlternativeFinder.h =================================================================== --- src/ResolvExpr/AlternativeFinder.h (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/ResolvExpr/AlternativeFinder.h (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -73,4 +73,5 @@ virtual void visit( UniqueExpr *unqExpr ); virtual void visit( StmtExpr *stmtExpr ); + virtual void visit( UntypedInitExpr *initExpr ); /// Runs a new alternative finder on each element in [begin, end) /// and writes each alternative finder to out. Index: src/ResolvExpr/CurrentObject.cc =================================================================== --- src/ResolvExpr/CurrentObject.cc (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) +++ src/ResolvExpr/CurrentObject.cc (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -0,0 +1,587 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// CurrentObject.h -- +// +// Author : Rob Schluntz +// Created On : Tue Jun 13 15:28:32 2017 +// Last Modified By : Rob Schluntz +// Last Modified On : Tue Jun 13 15:28:44 2017 +// Update Count : 2 +// + +#include +#include + +#include "CurrentObject.h" + +#include "SynTree/Declaration.h" +#include "SynTree/Initializer.h" +#include "SynTree/Type.h" +#include "SynTree/TypeSubstitution.h" + +#if 0 +#define PRINT(x) x +#else +#define PRINT(x) +#endif + +namespace ResolvExpr { + long long int getConstValue( ConstantExpr * constExpr ) { + if ( BasicType * basicType = dynamic_cast< BasicType * >( constExpr->get_result() ) ) { + if ( basicType->isInteger() ) { + return constExpr->get_constant()->get_ival(); + } else { + assertf( false, "Non-integer constant expression in getConstValue", toString( constExpr ).c_str() ); // xxx - might be semantic error + } + } else if ( dynamic_cast< OneType * >( constExpr->get_result() ) ) { + return 1; + } else if ( dynamic_cast< ZeroType * >( constExpr->get_result() ) ) { + return 0; + } else { + assertf( false, "unhandled type on getConstValue %s", toString( constExpr->get_result() ).c_str() ); // xxx - might be semantic error + } + } + + struct Indenter { + static const int amt = 2; + unsigned int indent = 0; + + Indenter & operator+=(int nlevels) { indent += amt*nlevels; return *this; } + Indenter & operator-=(int nlevels) { indent -= amt*nlevels; return *this; } + Indenter operator+(int nlevels) { Indenter indenter = *this; return indenter += nlevels; } + Indenter operator-(int nlevels) { Indenter indenter = *this; return indenter -= nlevels; } + Indenter & operator++() { return *this += 1; } + Indenter & operator--() { return *this -= 1; } + }; + std::ostream & operator<<( std::ostream & out, Indenter & indent ) { + return out << std::string(indent.indent, ' '); + } + + 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; + } + + TypeSubstitution makeGenericSubstitution( Type * type ) { + if ( StructInstType * inst = dynamic_cast< StructInstType * >( type ) ) { + return makeGenericSubstitution( inst ); + } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( type ) ) { + return makeGenericSubstitution( inst ); + } else { + return TypeSubstitution(); + } + } + + class MemberIterator { + public: + virtual ~MemberIterator() {} + + virtual void setPosition( std::list< Expression * > & designators ) = 0; + virtual std::list operator*() const = 0; + virtual operator bool() const = 0; + virtual MemberIterator & bigStep() = 0; + virtual MemberIterator & smallStep() = 0; + virtual Type * getType() = 0; + virtual Type * getNext() = 0; + + virtual void print( std::ostream & out, Indenter indent ) const = 0; + + virtual std::list first() const = 0; // should be protected + }; + + std::ostream & operator<<(std::ostream & out, const MemberIterator & it) { + Indenter indenter; + it.print( out, indenter ); + return out; + } + + /// create a new MemberIterator that traverses a type correctly + MemberIterator * createMemberIterator( Type * type ); + + /// iterates "other" types, e.g. basic types, pointer types, etc. which do not change at list initializer entry + class SimpleIterator : public MemberIterator { + public: + SimpleIterator( Type * type ) : type( type ) {} + + virtual void setPosition( std::list< Expression * > & designators ) { + assertf( designators.empty(), "simple iterator given non-empty designator..." ); // xxx - might be semantic error + } + + virtual std::list operator*() const { return first(); } + virtual operator bool() const { return type; } + + // big step is the same as small step + virtual MemberIterator & bigStep() { return smallStep(); } + virtual MemberIterator & smallStep() { + type = nullptr; // type is nullified on increment since SimpleIterators do not have members + return *this; + } + + virtual void print( std::ostream & out, Indenter indent ) const { + out << "SimpleIterator(" << type << ")"; + } + + virtual Type * getType() { return type; } + virtual Type * getNext() { return type; } + + protected: + virtual std::list first() const { + if ( type ) return std::list{ { type->clone(), new Designation( {} ) } }; + else return std::list{}; + } + private: + Type * type = nullptr; + }; + + class ArrayIterator : public MemberIterator { + public: + ArrayIterator( ArrayType * at ) : array( at ) { + PRINT( std::cerr << "Creating array iterator: " << at << std::endl; ) + base = at->get_base(); + memberIter = createMemberIterator( base ); + setSize( at->get_dimension() ); + } + + ~ArrayIterator() { + delete memberIter; + } + + private: + void setSize( Expression * expr ) { + if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( expr ) ) { + size = getConstValue( constExpr ); + PRINT( std::cerr << "array type with size: " << size << std::endl; ) + } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) { + setSize( castExpr->get_arg() ); // xxx - need to perform the conversion specified by the cast + } else { + assertf( false, "unhandled expression in setSize: %s", toString( expr ).c_str() ); // xxx - if not a constant expression, it's not simple to determine how long the array actually is, which is necessary for initialization to be done correctly -- fix this + } + } + + public: + void setPosition( Expression * expr ) { + // need to permit integer-constant-expressions, including: integer constants, enumeration constants, character constants, sizeof expressions, _Alignof expressions, cast expressions + if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( expr ) ) { + index = getConstValue( constExpr ); + } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) { + setPosition( castExpr->get_arg() ); + } else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) { + assertf( dynamic_cast ( varExpr->get_result() ), "ArrayIterator given variable that isn't an enum constant", toString( expr ).c_str() ); + index = 0; // xxx - get actual value of enum constant + } else if ( dynamic_cast< SizeofExpr * >( expr ) || dynamic_cast< AlignofExpr * >( expr ) ) { + index = 0; // xxx - get actual sizeof/alignof value? + } else { + assertf( false, "bad designator given to ArrayIterator: %s", toString( expr ).c_str() ); + } + } + + virtual void setPosition( std::list< Expression * > & designators ) { + if ( ! designators.empty() ) { + setPosition( designators.front() ); + designators.pop_front(); + memberIter->setPosition( designators ); + } + } + + virtual std::list operator*() const { + return first(); + } + + virtual operator bool() const { return index < size; } + + virtual MemberIterator & bigStep() { + PRINT( std::cerr << "bigStep in ArrayIterator (" << index << "/" << size << ")" << std::endl; ) + ++index; + delete memberIter; + if ( index < size ) memberIter = createMemberIterator( base ); + else memberIter = nullptr; + return *this; + } + + virtual MemberIterator & smallStep() { + PRINT( std::cerr << "smallStep in ArrayIterator (" << index << "/" << size << ")" << std::endl; ) + if ( memberIter ) { + PRINT( std::cerr << "has member iter: " << *memberIter << std::endl; ) + memberIter->smallStep(); + if ( *memberIter ) { + PRINT( std::cerr << "has valid member iter" << std::endl; ) + return *this; + } + } + return bigStep(); + } + + virtual Type * getType() { return array; } + virtual Type * getNext() { return base; } + + virtual std::list first() const { + PRINT( std::cerr << "first in ArrayIterator (" << index << "/" << size << ")" << std::endl; ) + if ( memberIter && *memberIter ) { + std::list ret = memberIter->first(); + for ( InitAlternative & alt : ret ) { + alt.designation->get_designators().push_front( new ConstantExpr( Constant::from_ulong( index ) ) ); + } + return ret; + } + return std::list(); + } + + virtual void print( std::ostream & out, Indenter indent ) const { + out << "ArrayIterator(Array of " << base << ")"; + if ( memberIter ) { + Indenter childIndent = indent+1; + out << std::endl << childIndent; + memberIter->print( out, childIndent ); + } + } + + private: + ArrayType * array = nullptr; + Type * base = nullptr; + size_t index = 0; + size_t size = 0; + MemberIterator * memberIter = nullptr; + }; + + class AggregateIterator : public MemberIterator { + public: + typedef std::list MemberList; + typedef MemberList::const_iterator iterator; + std::string kind = ""; // for debug + std::string name; + Type * inst = nullptr; + const MemberList & members; + iterator curMember; + bool atbegin = true; // false at first {small,big}Step -- this aggr type is only added to the possibilities at the beginning + Type * curType = nullptr; + MemberIterator * memberIter = nullptr; + mutable TypeSubstitution sub; + + AggregateIterator( const std::string & kind, const std::string & name, Type * inst, const MemberList & members ) : kind( kind ), name( name ), inst( inst ), members( members ), curMember( members.begin() ), sub( makeGenericSubstitution( inst ) ) { + init(); + } + + virtual ~AggregateIterator() { + delete memberIter; + } + + bool init() { + PRINT( std::cerr << "--init()--" << members.size() << std::endl; ) + if ( curMember != members.end() ) { + if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( *curMember ) ) { + PRINT( std::cerr << "incremented to field: " << field << std::endl; ) + curType = field->get_type(); + memberIter = createMemberIterator( curType ); + return true; + } + } + return false; + } + + virtual std::list operator*() const { + if (memberIter && *memberIter) { + std::list ret = memberIter->first(); + PRINT( std::cerr << "sub: " << sub << std::endl; ) + for ( InitAlternative & alt : ret ) { + PRINT( std::cerr << "iterating and adding designators" << std::endl; ) + alt.designation->get_designators().push_front( new VariableExpr( safe_dynamic_cast< ObjectDecl * >( *curMember ) ) ); + // need to substitute for generic types, so that casts are to concrete types + PRINT( std::cerr << " type is: " << alt.type; ) + sub.apply( alt.type ); // also apply to designation?? + PRINT( std::cerr << " ==> " << alt.type << std::endl; ) + } + return ret; + } + return std::list(); + } + + virtual void setPosition( std::list< Expression * > & designators ) { + if ( ! designators.empty() ) { + if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( designators.front() ) ) { + for ( curMember = members.begin(); curMember != members.end(); ++curMember ) { + if ( *curMember == varExpr->get_var() ) { + designators.pop_front(); + delete memberIter; + memberIter = createMemberIterator( varExpr->get_result() ); + curType = varExpr->get_result(); + atbegin = curMember == members.begin() && designators.empty(); // xxx - is this the right condition for atbegin?? + memberIter->setPosition( designators ); + return; + } // if + } // for + assertf( false, "could not find member in %s: %s", kind.c_str(), toString( varExpr ).c_str() ); + } else { + assertf( false, "bad designator given to %s: %s", kind.c_str(), toString( designators.front() ).c_str() ); + } // if + } // if + } + + virtual MemberIterator & smallStep() { + PRINT( std::cerr << "smallStep in " << kind << std::endl; ) + atbegin = false; + if ( memberIter ) { + PRINT( std::cerr << "has member iter, incrementing..." << std::endl; ) + memberIter->smallStep(); + if ( *memberIter ) { + PRINT( std::cerr << "success!" << std::endl; ) + return *this; + } + } + return bigStep(); + } + + virtual Type * getType() { return inst; } + virtual Type * getNext() { + if ( memberIter && *memberIter ) return memberIter->getType(); // xxx - ??? recursive call??? + return nullptr; + } + + virtual std::list first() const { + std::list ret; + PRINT( std::cerr << "first " << kind << std::endl; ) + if ( memberIter && *memberIter ) { // might not need *memberIter?? + PRINT( std::cerr << "adding children" << std::endl; ) + ret = memberIter->first(); + for ( InitAlternative & alt : ret ) { + PRINT( std::cerr << "iterating and adding designators" << std::endl; ) + alt.designation->get_designators().push_front( new VariableExpr( safe_dynamic_cast< ObjectDecl * >( *curMember ) ) ); + } + } + // if ( curMember == std::next( decl->get_members().begin(), 1 ) ) { // xxx - this never triggers because curMember is incremented immediately on construction + if ( atbegin ) { // xxx - this never triggers because curMember is incremented immediately on construction + // xxx - what about case of empty struct?? + // only add self if at the very beginning of the structure + PRINT( std::cerr << "adding self" << std::endl; ) + ret.push_front( { inst->clone(), new Designation( {} ) } ); + } + return ret; + } + + virtual void print( std::ostream & out, Indenter indent ) const { + out << kind << "(" << name << ")"; + if ( memberIter ) { + Indenter childIndent = indent+1; + out << std::endl << childIndent; + memberIter->print( out, childIndent ); + } + } + }; + + class UnionIterator : public AggregateIterator { + public: + UnionIterator( UnionInstType * inst ) : AggregateIterator( "UnionIterator", inst->get_name(), inst, inst->get_baseUnion()->get_members() ) {} + + virtual operator bool() const { return (memberIter && *memberIter); } + virtual MemberIterator & bigStep() { + // unions only initialize one member + PRINT( std::cerr << "bigStep in " << kind << std::endl; ) + atbegin = false; + delete memberIter; + memberIter = nullptr; + curType = nullptr; + curMember = members.end(); + return *this; + } + virtual std::list first() const { return std::list{}; } + }; + + class StructIterator : public AggregateIterator { + public: + StructIterator( StructInstType * inst ) : AggregateIterator( "StructIterator", inst->get_name(), inst, inst->get_baseStruct()->get_members() ) {} + + virtual operator bool() const { return curMember != members.end() || (memberIter && *memberIter); } + + virtual MemberIterator & bigStep() { + PRINT( std::cerr << "bigStep in " << kind << std::endl; ) + atbegin = false; + delete memberIter; + memberIter = nullptr; + curType = nullptr; + for ( ; curMember != members.end(); ) { + ++curMember; + if ( init() ) { + return *this; + } + } + return *this; + } + }; + + class TupleIterator : public AggregateIterator { + public: + TupleIterator( TupleType * inst ) : AggregateIterator( "TupleIterator", toString("Tuple", inst->size()), inst, inst->get_members() ) {} + + virtual operator bool() const { return curMember != members.end() || (memberIter && *memberIter); } + + virtual MemberIterator & bigStep() { + PRINT( std::cerr << "bigStep in " << kind << std::endl; ) + atbegin = false; + delete memberIter; + memberIter = nullptr; + curType = nullptr; + for ( ; curMember != members.end(); ) { + ++curMember; + if ( init() ) { + return *this; + } + } + return *this; + } + }; + + MemberIterator * createMemberIterator( Type * type ) { + if ( ReferenceToType * aggr = dynamic_cast< ReferenceToType * >( type ) ) { + if ( StructInstType * sit = dynamic_cast< StructInstType * >( aggr ) ) { + return new StructIterator( sit ); + } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( aggr ) ) { + return new UnionIterator( uit ); + } else { + assertf( dynamic_cast< TypeInstType * >( type ), "some other reftotype" ); + return new SimpleIterator( type ); + } + } else if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) { + return new ArrayIterator( at ); + } else if ( TupleType * tt = dynamic_cast< TupleType * >( type ) ) { + return new TupleIterator( tt ); + } else { + return new SimpleIterator( type ); + } + } + + CurrentObject::CurrentObject() {} + CurrentObject::CurrentObject( Type * type ) { + objStack.push( new SimpleIterator( type ) ); + } + + + void CurrentObject::setNext( Designation * designation ) { + assertf( ! objStack.empty(), "obj stack empty in setNext" ); + PRINT( std::cerr << "____setNext" << designation << std::endl; ) + objStack.top()->setPosition( designation->get_designators() ); + } + + Designation * CurrentObject::findNext( Designation * designation ) { + typedef std::list< Expression * > DesignatorChain; + PRINT( std::cerr << "___findNext" << std::endl; ) + // find all the d's + std::list desigAlts{ { } }, newDesigAlts; + std::list curTypes { (objStack.top())->getType() }, newTypes; + for ( Expression * expr : designation->get_designators() ) { + PRINT( std::cerr << "____untyped: " << expr << std::endl; ) + std::list::iterator dit = desigAlts.begin(); + if ( NameExpr * nexpr = dynamic_cast(expr) ) { + for ( Type * t : curTypes ) { + assert( dit != desigAlts.end() ); + DesignatorChain & d = *dit; + PRINT( std::cerr << "____actual: " << t << std::endl; ) + ReferenceToType * refType = dynamic_cast(t); + std::list members; + if ( refType ) { + refType->lookup( nexpr->get_name(), members ); // concatenate identical field name + // xxx - need to also include anonymous members in this somehow... + for ( Declaration * mem: members ) { + if ( ObjectDecl * field = dynamic_cast(mem) ) { + PRINT( std::cerr << "____alt: " << field->get_type() << std::endl; ) + DesignatorChain newD = d; + newD.push_back( new VariableExpr( field ) ); + newDesigAlts.push_back( newD ); + newTypes.push_back( field->get_type() ); + } // if + } // for + } // if + ++dit; + } // for + } else { + for ( Type * t : curTypes ) { + assert( dit != desigAlts.end() ); + DesignatorChain & d = *dit; + if ( ArrayType * at = dynamic_cast< ArrayType * > ( t ) ) { + PRINT( std::cerr << "____alt: " << at->get_base() << std::endl; ) + d.push_back( expr ); + newDesigAlts.push_back( d ); + newTypes.push_back( at->get_base() ); + } + ++dit; + } // for + } // if + desigAlts = newDesigAlts; + newDesigAlts.clear(); + curTypes = newTypes; + newTypes.clear(); + assertf( desigAlts.size() == curTypes.size(), "Designator alternatives (%d) and current types (%d) out of sync", desigAlts.size(), curTypes.size() ); + } // for + if ( desigAlts.size() > 1 ) { + throw SemanticError( toString("Too many alternatives (", desigAlts.size(), ") for designation: "), designation ); + } else if ( desigAlts.size() == 0 ) { + throw SemanticError( "No reasonable alternatives for designation: ", 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( d ); + objStack.top()->setPosition( d ); // destroys d + return actualDesignation; + } + + void CurrentObject::increment() { + PRINT( std::cerr << "____increment" << std::endl; ) + if ( ! objStack.empty() ) { + PRINT( std::cerr << *objStack.top() << std::endl; ) + objStack.top()->smallStep(); + } + } + + void CurrentObject::enterListInit() { + PRINT( std::cerr << "____entering list init" << std::endl; ) + assertf( ! objStack.empty(), "empty obj stack entering list init" ); + Type * type = objStack.top()->getNext(); + if ( type ) { + objStack.push( createMemberIterator( type ) ); + } else { + assertf( false, "not sure about this case..." ); + } + } + + void CurrentObject::exitListInit() { + PRINT( std::cerr << "____exiting list init" << std::endl; ) + assertf( ! objStack.empty(), "objstack empty" ); + delete objStack.top(); + objStack.pop(); + if ( ! objStack.empty() ) { + PRINT( std::cerr << *objStack.top() << std::endl; ) + objStack.top()->bigStep(); + } + } + + std::list< InitAlternative > CurrentObject::getOptions() { + PRINT( std::cerr << "____getting current options" << std::endl; ) + assertf( ! objStack.empty(), "objstack empty in getOptions" ); + return **objStack.top(); + } + + Type * CurrentObject::getCurrentType() { + PRINT( std::cerr << "____getting current type" << std::endl; ) + assertf( ! objStack.empty(), "objstack empty in getCurrentType" ); + return objStack.top()->getNext(); + } +} // namespace ResolvExpr + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/ResolvExpr/CurrentObject.h =================================================================== --- src/ResolvExpr/CurrentObject.h (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) +++ src/ResolvExpr/CurrentObject.h (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -0,0 +1,59 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// CurrentObject.h -- +// +// Author : Rob Schluntz +// Created On : Thu Jun 8 11:07:25 2017 +// Last Modified By : Rob Schluntz +// Last Modified On : Thu Jun 8 11:07:41 2017 +// Update Count : 2 +// + +#ifndef CURRENT_OBJECT_H +#define CURRENT_OBJECT_H + +#include + +#include "SynTree/SynTree.h" +#include "SynTree/Expression.h" + +namespace ResolvExpr { + class MemberIterator; + + class CurrentObject { + public: + CurrentObject(); + CurrentObject( Type * type ); + + /// resolves unresolved designation + Designation * findNext( Designation * designation ); + /// sets current position using resolved designation + void setNext( Designation * designation ); + /// steps to next sub-object of current-object + void increment(); + /// sets new current-object for the duration of this brace-enclosed initializer-list + void enterListInit(); + /// restores previous current-object + void exitListInit(); + /// produces a list of alternatives (Type *, Designation *) for the current sub-object's initializer + std::list< InitAlternative > getOptions(); + /// produces the type of the current object but no subobjects + Type * getCurrentType(); + + private: + std::stack< MemberIterator * > objStack; + }; +} // namespace ResolvExpr + +#endif // CURRENT_OBJECT_H + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // + Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/ResolvExpr/Resolver.cc (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -14,20 +14,26 @@ // +#include + +#include "Alternative.h" +#include "AlternativeFinder.h" +#include "CurrentObject.h" +#include "RenameVars.h" #include "Resolver.h" -#include "AlternativeFinder.h" -#include "Alternative.h" -#include "RenameVars.h" #include "ResolveTypeof.h" #include "typeops.h" + +#include "SynTree/Expression.h" +#include "SynTree/Initializer.h" #include "SynTree/Statement.h" #include "SynTree/Type.h" -#include "SynTree/Expression.h" -#include "SynTree/Initializer.h" + +#include "SymTab/Autogen.h" #include "SymTab/Indexer.h" -#include "SymTab/Autogen.h" + #include "Common/utility.h" + #include "InitTweak/InitTweak.h" -#include using namespace std; @@ -39,5 +45,5 @@ if ( const Resolver * res = dynamic_cast< const Resolver * >( &other ) ) { functionReturn = res->functionReturn; - initContext = res->initContext; + currentObject = res->currentObject; inEnumDecl = res->inEnumDecl; } @@ -79,5 +85,5 @@ Type * functionReturn = nullptr; - Type *initContext = nullptr; + CurrentObject currentObject = nullptr; bool inEnumDecl = false; }; @@ -186,17 +192,16 @@ // each value of initContext is retained, so the type on the first analysis is preserved and used for selecting // the RHS. - Type *temp = initContext; - initContext = new_type; - if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) { + ValueGuard temp( currentObject ); + currentObject = CurrentObject( objectDecl->get_type() ); + if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) { // enumerator initializers should not use the enum type to initialize, since // the enum type is still incomplete at this point. Use signed int instead. - initContext = new BasicType( Type::Qualifiers(), BasicType::SignedInt ); + currentObject = CurrentObject( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ); } Parent::visit( objectDecl ); - if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) { + if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) { // delete newly created signed int type - delete initContext; - } - initContext = temp; + // delete currentObject.getType(); + } } @@ -315,5 +320,5 @@ void Resolver::visit( SwitchStmt *switchStmt ) { - ValueGuard< Type * > oldInitContext( initContext ); + ValueGuard< CurrentObject > oldCurrentObject( currentObject ); Expression *newExpr; newExpr = findIntegralExpression( switchStmt->get_condition(), *this ); @@ -321,5 +326,5 @@ switchStmt->set_condition( newExpr ); - initContext = newExpr->get_result(); + currentObject = CurrentObject( newExpr->get_result() ); Parent::visit( switchStmt ); } @@ -327,6 +332,7 @@ void Resolver::visit( CaseStmt *caseStmt ) { if ( caseStmt->get_condition() ) { - assert( initContext ); - CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initContext->clone() ); + 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() ); Expression * newExpr = findSingleExpression( castExpr, *this ); castExpr = safe_dynamic_cast< CastExpr * >( newExpr ); @@ -370,205 +376,75 @@ void Resolver::visit( SingleInit *singleInit ) { - if ( singleInit->get_value() ) { - // // find all the d's - // std::list &designators = singleInit->get_designators(); - // std::list types1{ initContext }, types2; - // for ( Expression * expr: designators ) { - // cerr << expr << endl; - // if ( NameExpr * nexpr = dynamic_cast( expr ) ) { - // for ( Type * type: types1 ) { - // cerr << type << endl; - // ReferenceToType * fred = dynamic_cast(type); - // std::list members; - // if ( fred ) { - // fred->lookup( nexpr->get_name(), members ); // concatenate identical field name - // for ( Declaration * mem: members ) { - // if ( DeclarationWithType * dwt = dynamic_cast(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; - } + // 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(); + 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; } } } - } // 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 + } + + // set initializer expr to resolved express + singleInit->set_value( newExpr ); + + // move cursor to next object in preparation for next initializer + currentObject.increment(); } void Resolver::visit( ListInit * listInit ) { - 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(initContext) ) { - std::list::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(initContext) ) { - StructDecl *baseStruct = st->get_baseStruct(); - std::list::iterator iter1( baseStruct->get_members().begin() ); - std::list::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( *iter1 ); - initContext = dt->get_type(); - (*iter2)->accept( *this ); - ++iter1; - } else { - StructDecl *st = baseStruct; - iter1 = st->get_members().begin(); - std::list::iterator iter3( (*iter2)->get_designators().begin() ); - for ( ; iter3 != (*iter2)->get_designators().end(); ++iter3 ) { - NameExpr *key = dynamic_cast( *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( *iter1 ); - assert( fred ); - StructInstType *mary = dynamic_cast( fred->get_type() ); - assert( mary ); - st = mary->get_baseStruct(); - iter1 = st->get_members().begin(); - break; - } // if - } // for - } // for - ObjectDecl *fred = dynamic_cast( *iter1 ); - assert( fred ); - initContext = fred->get_type(); - (*listInit->begin_initializers())->accept( *this ); - } // if - } // for - } else if ( UnionInstType *st = dynamic_cast(initContext) ) { - DeclarationWithType *dt = dynamic_cast( *st->get_baseUnion()->get_members().begin() ); - initContext = dt->get_type(); - (*listInit->begin_initializers())->accept( *this ); - } // if -#endif + // 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 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 { } Index: src/ResolvExpr/Unify.cc =================================================================== --- src/ResolvExpr/Unify.cc (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/ResolvExpr/Unify.cc (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -606,8 +606,8 @@ } else if ( tupleParam ) { // bundle other parameters into tuple to match - TupleType* binder = new TupleType{ paramTy->get_qualifiers() }; + std::list< Type * > binderTypes; do { - binder->get_types().push_back( otherParam->get_type()->clone() ); + binderTypes.push_back( otherParam->get_type()->clone() ); ++jt; @@ -618,12 +618,12 @@ } while (true); - otherParamTy = binder; + otherParamTy = new TupleType{ paramTy->get_qualifiers(), binderTypes }; ++it; // skip ttype parameter for break } else if ( otherTupleParam ) { // bundle parameters into tuple to match other - TupleType* binder = new TupleType{ otherParamTy->get_qualifiers() }; + std::list< Type * > binderTypes; do { - binder->get_types().push_back( param->get_type()->clone() ); + binderTypes.push_back( param->get_type()->clone() ); ++it; @@ -634,5 +634,5 @@ } while (true); - paramTy = binder; + paramTy = new TupleType{ otherParamTy->get_qualifiers(), binderTypes }; ++jt; // skip ttype parameter for break } @@ -756,9 +756,9 @@ return function->get_returnVals().front()->get_type()->clone(); } else { - TupleType * tupleType = new TupleType( Type::Qualifiers() ); + std::list< Type * > types; for ( DeclarationWithType * decl : function->get_returnVals() ) { - tupleType->get_types().push_back( decl->get_type()->clone() ); + types.push_back( decl->get_type()->clone() ); } // for - return tupleType; + return new TupleType( Type::Qualifiers(), types ); } } Index: src/ResolvExpr/module.mk =================================================================== --- src/ResolvExpr/module.mk (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/ResolvExpr/module.mk (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -6,5 +6,5 @@ ## file "LICENCE" distributed with Cforall. ## -## module.mk -- +## module.mk -- ## ## Author : Richard C. Bilson @@ -31,3 +31,4 @@ ResolvExpr/PolyCost.cc \ ResolvExpr/Occurs.cc \ - ResolvExpr/TypeEnvironment.cc + ResolvExpr/TypeEnvironment.cc \ + ResolvExpr/CurrentObject.cc Index: src/SymTab/Autogen.h =================================================================== --- src/SymTab/Autogen.h (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/SymTab/Autogen.h (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -25,21 +25,21 @@ namespace SymTab { - /// Generates assignment operators, constructors, and destructor for aggregate types as required - void autogenerateRoutines( std::list< Declaration * > &translationUnit ); + /// Generates assignment operators, constructors, and destructor for aggregate types as required + void autogenerateRoutines( std::list< Declaration * > &translationUnit ); - /// returns true if obj's name is the empty string and it has a bitfield width - bool isUnnamedBitfield( ObjectDecl * obj ); + /// returns true if obj's name is the empty string and it has a bitfield width + bool isUnnamedBitfield( ObjectDecl * obj ); - /// size_t type - set when size_t typedef is seen. Useful in a few places, - /// such as in determining array dimension type - extern Type * SizeType; + /// size_t type - set when size_t typedef is seen. Useful in a few places, + /// such as in determining array dimension type + extern Type * SizeType; - /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. - template< typename OutputIterator > + /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. + template< typename OutputIterator > Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false, bool forward = true ); - /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types. - /// optionally returns a statement which must be inserted prior to the containing loop, if there is one - template< typename OutputIterator > + /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types. + /// optionally returns a statement which must be inserted prior to the containing loop, if there is one + template< typename OutputIterator > Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false ) { // want to be able to generate assignment, ctor, and dtor generically, @@ -50,16 +50,15 @@ dstParam = new AddressExpr( dstParam ); if ( addCast ) { - // cast to T* with qualifiers removed, so that qualified objects can be constructed - // and destructed with the same functions as non-qualified objects. - // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument - // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever - // remove lvalue as a qualifier, this can change to - // type->get_qualifiers() = Type::Qualifiers(); - assert( type ); - Type * castType = type->clone(); -// castType->get_qualifiers() -= Type::Qualifiers(true, true, true, false, true, false); - castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic ); - castType->set_lvalue( true ); // xxx - might not need this - dstParam = new CastExpr( dstParam, new PointerType( Type::Qualifiers(), castType ) ); + // cast to T* with qualifiers removed, so that qualified objects can be constructed + // and destructed with the same functions as non-qualified objects. + // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument + // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever + // remove lvalue as a qualifier, this can change to + // type->get_qualifiers() = Type::Qualifiers(); + assert( type ); + Type * castType = type->clone(); + castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic ); + castType->set_lvalue( true ); // xxx - might not need this + dstParam = new CastExpr( dstParam, new PointerType( Type::Qualifiers(), castType ) ); } fExpr->get_args().push_back( dstParam ); @@ -75,103 +74,103 @@ return listInit; - } - - /// Store in out a loop which calls fname on each element of the array with srcParam and dstParam as arguments. - /// If forward is true, loop goes from 0 to N-1, else N-1 to 0 - template< typename OutputIterator > - void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool addCast = false, bool forward = true ) { - static UniqueName indexName( "_index" ); - - // for a flexible array member nothing is done -- user must define own assignment - if ( ! array->get_dimension() ) return ; - - Expression * begin, * end, * update, * cmp; - if ( forward ) { - // generate: for ( int i = 0; i < N; ++i ) - begin = new ConstantExpr( Constant::from_int( 0 ) ); - end = array->get_dimension()->clone(); - cmp = new NameExpr( "?= 0; --i ) - begin = new UntypedExpr( new NameExpr( "?-?" ) ); - ((UntypedExpr*)begin)->get_args().push_back( array->get_dimension()->clone() ); - ((UntypedExpr*)begin)->get_args().push_back( new ConstantExpr( Constant::from_int( 1 ) ) ); - end = new ConstantExpr( Constant::from_int( 0 ) ); - cmp = new NameExpr( "?>=?" ); - update = new NameExpr( "--?" ); } - ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list() ) ); + /// Store in out a loop which calls fname on each element of the array with srcParam and dstParam as arguments. + /// If forward is true, loop goes from 0 to N-1, else N-1 to 0 + template< typename OutputIterator > + void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool addCast = false, bool forward = true ) { + static UniqueName indexName( "_index" ); - UntypedExpr *cond = new UntypedExpr( cmp ); - cond->get_args().push_back( new VariableExpr( index ) ); - cond->get_args().push_back( end ); + // for a flexible array member nothing is done -- user must define own assignment + if ( ! array->get_dimension() ) return ; - UntypedExpr *inc = new UntypedExpr( update ); - inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) ); + Expression * begin, * end, * update, * cmp; + if ( forward ) { + // generate: for ( int i = 0; i < N; ++i ) + begin = new ConstantExpr( Constant::from_int( 0 ) ); + end = array->get_dimension()->clone(); + cmp = new NameExpr( "?= 0; --i ) + begin = new UntypedExpr( new NameExpr( "?-?" ) ); + ((UntypedExpr*)begin)->get_args().push_back( array->get_dimension()->clone() ); + ((UntypedExpr*)begin)->get_args().push_back( new ConstantExpr( Constant::from_int( 1 ) ) ); + end = new ConstantExpr( Constant::from_int( 0 ) ); + cmp = new NameExpr( "?>=?" ); + update = new NameExpr( "--?" ); + } - UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) ); - dstIndex->get_args().push_back( dstParam ); - dstIndex->get_args().push_back( new VariableExpr( index ) ); - dstParam = dstIndex; + ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin ) ); - // srcParam must keep track of the array indices to build the - // source parameter and/or array list initializer - srcParam.addArrayIndex( new VariableExpr( index ), array->get_dimension()->clone() ); + UntypedExpr *cond = new UntypedExpr( cmp ); + cond->get_args().push_back( new VariableExpr( index ) ); + cond->get_args().push_back( end ); - // for stmt's body, eventually containing call - CompoundStmt * body = new CompoundStmt( noLabels ); - Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->get_kids() ), array->get_base(), addCast, forward ); + UntypedExpr *inc = new UntypedExpr( update ); + inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) ); - // block containing for stmt and index variable - std::list initList; - CompoundStmt * block = new CompoundStmt( noLabels ); - block->get_kids().push_back( new DeclStmt( noLabels, index ) ); - if ( listInit ) block->get_kids().push_back( listInit ); - block->get_kids().push_back( new ForStmt( noLabels, initList, cond, inc, body ) ); + UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) ); + dstIndex->get_args().push_back( dstParam ); + dstIndex->get_args().push_back( new VariableExpr( index ) ); + dstParam = dstIndex; - *out++ = block; - } + // srcParam must keep track of the array indices to build the + // source parameter and/or array list initializer + srcParam.addArrayIndex( new VariableExpr( index ), array->get_dimension()->clone() ); - template< typename OutputIterator > + // for stmt's body, eventually containing call + CompoundStmt * body = new CompoundStmt( noLabels ); + Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->get_kids() ), array->get_base(), addCast, forward ); + + // block containing for stmt and index variable + std::list initList; + CompoundStmt * block = new CompoundStmt( noLabels ); + block->get_kids().push_back( new DeclStmt( noLabels, index ) ); + if ( listInit ) block->get_kids().push_back( listInit ); + block->get_kids().push_back( new ForStmt( noLabels, initList, cond, inc, body ) ); + + *out++ = block; + } + + template< typename OutputIterator > Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast, bool forward ) { - if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) { - genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward ); - return 0; - } else { - return genScalarCall( srcParam, dstParam, fname, out, type, addCast ); + if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) { + genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward ); + return 0; + } else { + return genScalarCall( srcParam, dstParam, fname, out, type, addCast ); + } } - } - /// inserts into out a generated call expression to function fname with arguments dstParam - /// and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. decl is the - /// object being constructed. The function wraps constructor and destructor calls in an - /// ImplicitCtorDtorStmt node. - template< typename OutputIterator > + /// inserts into out a generated call expression to function fname with arguments dstParam + /// and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. decl is the + /// object being constructed. The function wraps constructor and destructor calls in an + /// ImplicitCtorDtorStmt node. + template< typename OutputIterator > void genImplicitCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) { - ObjectDecl *obj = dynamic_cast( decl ); - assert( obj ); - // unnamed bit fields are not copied as they cannot be accessed - if ( isUnnamedBitfield( obj ) ) return; + ObjectDecl *obj = dynamic_cast( decl ); + assert( obj ); + // unnamed bit fields are not copied as they cannot be accessed + if ( isUnnamedBitfield( obj ) ) return; - bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && obj->get_bitfieldWidth() == NULL ) ); - std::list< Statement * > stmts; - genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->get_type(), addCast, forward ); + bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && obj->get_bitfieldWidth() == NULL ) ); + std::list< Statement * > stmts; + genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->get_type(), addCast, forward ); - // currently genCall should produce at most one element, but if that changes then the next line needs to be updated to grab the statement which contains the call - assert( stmts.size() <= 1 ); - if ( stmts.size() == 1 ) { - Statement * callStmt = stmts.front(); - if ( addCast ) { - // implicitly generated ctor/dtor calls should be wrapped - // so that later passes are aware they were generated. - // xxx - don't mark as an implicit ctor/dtor if obj is a bitfield, - // because this causes the address to be taken at codegen, which is illegal in C. - callStmt = new ImplicitCtorDtorStmt( callStmt ); - } - *out++ = callStmt; + // currently genCall should produce at most one element, but if that changes then the next line needs to be updated to grab the statement which contains the call + assert( stmts.size() <= 1 ); + if ( stmts.size() == 1 ) { + Statement * callStmt = stmts.front(); + if ( addCast ) { + // implicitly generated ctor/dtor calls should be wrapped + // so that later passes are aware they were generated. + // xxx - don't mark as an implicit ctor/dtor if obj is a bitfield, + // because this causes the address to be taken at codegen, which is illegal in C. + callStmt = new ImplicitCtorDtorStmt( callStmt ); + } + *out++ = callStmt; + } } - } } // namespace SymTab #endif // AUTOGEN_H Index: src/SymTab/ImplementationType.cc =================================================================== --- src/SymTab/ImplementationType.cc (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/SymTab/ImplementationType.cc (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -5,5 +5,5 @@ // file "LICENCE" distributed with Cforall. // -// ImplementationType.cc -- +// ImplementationType.cc -- // // Author : Richard C. Bilson @@ -92,11 +92,11 @@ void ImplementationType::visit(TupleType *tupleType) { - TupleType *newType = new TupleType( Type::Qualifiers() ); + std::list< Type * > types; for ( std::list< Type* >::iterator i = tupleType->get_types().begin(); i != tupleType->get_types().end(); ++i ) { Type *implType = implementationType( *i, indexer ); implType->get_qualifiers() |= tupleType->get_qualifiers(); - newType->get_types().push_back( implType ); + types.push_back( implType ); } // for - result = newType; + result = new TupleType( Type::Qualifiers(), types ); } Index: src/SynTree/Constant.cc =================================================================== --- src/SynTree/Constant.cc (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/SynTree/Constant.cc (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -5,5 +5,5 @@ // file "LICENCE" distributed with Cforall. // -// Constant.cc -- +// Constant.cc -- // // Author : Richard C. Bilson @@ -46,4 +46,14 @@ } +unsigned long long Constant::get_ival() const { + assertf( safe_dynamic_cast(type)->isInteger(), "Attempt to retrieve ival from non-integer constant." ); + return val.ival; +} + +double Constant::get_dval() const { + assertf( ! safe_dynamic_cast(type)->isInteger(), "Attempt to retrieve dval from integer constant." ); + return val.dval; +} + void Constant::print( std::ostream &os ) const { os << "(" << rep << " " << val.ival; Index: src/SynTree/Constant.h =================================================================== --- src/SynTree/Constant.h (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/SynTree/Constant.h (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -5,5 +5,5 @@ // file "LICENCE" distributed with Cforall. // -// Constant.h -- +// Constant.h -- // // Author : Richard C. Bilson @@ -32,4 +32,6 @@ std::string & get_value() { return rep; } void set_value( std::string newValue ) { rep = newValue; } + unsigned long long get_ival() const; + double get_dval() const; /// generates a boolean constant of the given bool Index: src/SynTree/Expression.cc =================================================================== --- src/SynTree/Expression.cc (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/SynTree/Expression.cc (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -21,11 +21,15 @@ #include +#include "Declaration.h" +#include "Expression.h" +#include "Initializer.h" +#include "Statement.h" #include "Type.h" -#include "Initializer.h" -#include "Expression.h" -#include "Declaration.h" -#include "Statement.h" #include "TypeSubstitution.h" +#include "VarExprReplacer.h" + #include "Common/utility.h" +#include "Common/PassVisitor.h" + #include "InitTweak/InitTweak.h" @@ -92,5 +96,4 @@ Declaration *decl = get_var(); - // if ( decl != 0) decl->print(os, indent + 2); if ( decl != 0) decl->printShort(os, indent + 2); os << std::endl; @@ -657,4 +660,46 @@ } +InitAlternative::InitAlternative( Type * type, Designation * designation ) : type( type ), designation( designation ) {} +InitAlternative::InitAlternative( const InitAlternative & other ) : type( maybeClone( other.type ) ), designation( maybeClone( other.designation ) ) {} +InitAlternative::~InitAlternative() { + delete type; + delete designation; +} + +UntypedInitExpr::UntypedInitExpr( Expression * expr, const std::list & initAlts ) : expr( expr ), initAlts( initAlts ) {} +UntypedInitExpr::UntypedInitExpr( const UntypedInitExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), initAlts( other.initAlts ) {} +UntypedInitExpr::~UntypedInitExpr() { + delete expr; +} + +void UntypedInitExpr::print( std::ostream & os, int indent ) const { + os << "Untyped Init Expression" << std::endl << std::string( indent+2, ' ' ); + expr->print( os, indent+2 ); + if ( ! initAlts.empty() ) { + for ( const InitAlternative & alt : initAlts ) { + os << std::string( indent+2, ' ' ) << "InitAlternative: "; + alt.type->print( os, indent+2 ); + alt.designation->print( os, indent+2 ); + } + } +} + +InitExpr::InitExpr( Expression * expr, Designation * designation ) : expr( expr ), designation( designation ) { + set_result( expr->get_result()->clone() ); +} +InitExpr::InitExpr( const InitExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), designation( maybeClone( other.designation) ) {} +InitExpr::~InitExpr() { + delete expr; + delete designation; +} + +void InitExpr::print( std::ostream & os, int indent ) const { + os << "Init Expression" << std::endl << std::string( indent+2, ' ' ); + expr->print( os, indent+2 ); + os << std::string( indent+2, ' ' ) << "with designation: "; + designation->print( os, indent+2 ); +} + + std::ostream & operator<<( std::ostream & out, const Expression * expr ) { if ( expr ) { Index: src/SynTree/Expression.h =================================================================== --- src/SynTree/Expression.h (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/SynTree/Expression.h (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -744,4 +744,56 @@ }; +struct InitAlternative { +public: + Type * type = nullptr; + Designation * designation = nullptr; + InitAlternative( Type * type, Designation * designation ); + InitAlternative( const InitAlternative & other ); + InitAlternative & operator=( const Initializer & other ) = delete; // at the moment this isn't used, and I don't want to implement it + ~InitAlternative(); +}; + +class UntypedInitExpr : public Expression { +public: + UntypedInitExpr( Expression * expr, const std::list & initAlts ); + UntypedInitExpr( const UntypedInitExpr & other ); + ~UntypedInitExpr(); + + Expression * get_expr() const { return expr; } + UntypedInitExpr * set_expr( Expression * newValue ) { expr = newValue; return this; } + + std::list & get_initAlts() { return initAlts; } + + virtual UntypedInitExpr * clone() const { return new UntypedInitExpr( * this ); } + virtual void accept( Visitor & v ) { v.visit( this ); } + virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); } + virtual void print( std::ostream & os, int indent = 0 ) const; +private: + Expression * expr; + std::list initAlts; +}; + +class InitExpr : public Expression { +public: + InitExpr( Expression * expr, Designation * designation ); + InitExpr( const InitExpr & other ); + ~InitExpr(); + + Expression * get_expr() const { return expr; } + InitExpr * set_expr( Expression * newValue ) { expr = newValue; return this; } + + Designation * get_designation() const { return designation; } + InitExpr * set_designation( Designation * newValue ) { designation = newValue; return this; } + + virtual InitExpr * clone() const { return new InitExpr( * this ); } + virtual void accept( Visitor & v ) { v.visit( this ); } + virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); } + virtual void print( std::ostream & os, int indent = 0 ) const; +private: + Expression * expr; + Designation * designation; +}; + + std::ostream & operator<<( std::ostream & out, const Expression * expr ); Index: src/SynTree/Initializer.cc =================================================================== --- src/SynTree/Initializer.cc (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/SynTree/Initializer.cc (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -19,75 +19,82 @@ #include "Common/utility.h" +Designation::Designation( const std::list< Expression * > & designators ) : designators( designators ) {} +Designation::Designation( const Designation & other ) : BaseSyntaxNode( other ) { + // std::cerr << "cloning designation" << std::endl; + cloneAll( other.designators, designators ); + // std::cerr << "finished cloning designation" << std::endl; +} + +Designation::~Designation() { + // std::cerr << "destroying designation" << std::endl; + deleteAll( designators ); + // std::cerr << "finished destroying designation" << std::endl; +} + +void Designation::print( std::ostream &os, int indent ) const { + if ( ! designators.empty() ) { + os << std::string(indent + 2, ' ' ) << "designated by: " << std::endl; + for ( std::list < Expression * >::const_iterator i = designators.begin(); i != designators.end(); i++ ) { + os << std::string(indent + 4, ' ' ); + ( *i )->print(os, indent + 4 ); + } + os << std::endl; + } // if +} + Initializer::Initializer( bool maybeConstructed ) : maybeConstructed( maybeConstructed ) {} Initializer::Initializer( const Initializer & other ) : BaseSyntaxNode( other ), maybeConstructed( other.maybeConstructed ) { } - - Initializer::~Initializer() {} -std::string Initializer::designator_name( Expression *des ) { - if ( NameExpr *n = dynamic_cast(des) ) - return n->get_name(); - else - throw 0; -} - -// void Initializer::print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent ) {} - -SingleInit::SingleInit( Expression *v, const std::list< Expression *> &_designators, bool maybeConstructed ) : Initializer( maybeConstructed ), value ( v ), designators( _designators ) { +SingleInit::SingleInit( Expression *v, bool maybeConstructed ) : Initializer( maybeConstructed ), value ( v ) { } SingleInit::SingleInit( const SingleInit &other ) : Initializer(other), value ( maybeClone( other.value ) ) { - cloneAll(other.designators, designators ); } SingleInit::~SingleInit() { delete value; - deleteAll(designators); } -void SingleInit::print( std::ostream &os, int indent ) { - os << std::endl << std::string(indent, ' ' ) << "Simple Initializer: " << std::endl; +void SingleInit::print( std::ostream &os, int indent ) const { + os << std::string(indent, ' ' ) << "Simple Initializer: " << std::endl; os << std::string(indent+4, ' ' ); value->print( os, indent+4 ); - - if ( ! designators.empty() ) { - os << std::endl << std::string(indent + 2, ' ' ) << "designated by: " << std::endl; - for ( std::list < Expression * >::iterator i = designators.begin(); i != designators.end(); i++ ) { - os << std::string(indent + 4, ' ' ); - ( *i )->print(os, indent + 4 ); - } - } // if } -ListInit::ListInit( const std::list &_initializers, const std::list &_designators, bool maybeConstructed ) - : Initializer( maybeConstructed ), initializers( _initializers ), designators( _designators ) { + +ListInit::ListInit( const std::list &inits, const std::list &des, bool maybeConstructed ) + : Initializer( maybeConstructed ), initializers( inits ), designations( des ) { + // handle the common case where a ListInit is created without designations by making a list of empty designations with the same length as the initializer + if ( designations.empty() ) { + for ( auto & i : initializers ) { + (void)i; + designations.push_back( new Designation( {} ) ); + } + } + assertf( initializers.size() == designations.size(), "Created ListInit with mismatching initializers (%d) and designations (%d)", initializers.size(), designations.size() ); } ListInit::ListInit( const ListInit & other ) : Initializer( other ) { cloneAll( other.initializers, initializers ); - cloneAll( other.designators, designators ); + cloneAll( other.designations, designations ); } - ListInit::~ListInit() { deleteAll( initializers ); - deleteAll( designators ); + deleteAll( designations ); } -void ListInit::print( std::ostream &os, int indent ) { - os << std::endl << std::string(indent, ' ') << "Compound initializer: "; - if ( ! designators.empty() ) { - os << std::string(indent + 2, ' ' ) << "designated by: ["; - for ( std::list < Expression * >::iterator i = designators.begin(); - i != designators.end(); i++ ) { - ( *i )->print(os, indent + 4 ); - } // for +void ListInit::print( std::ostream &os, int indent ) const { + os << std::string(indent, ' ') << "Compound initializer: " << std::endl; + for ( Designation * d : designations ) { + d->print( os, indent + 2 ); + } - os << std::string(indent + 2, ' ' ) << "]"; - } // if - - for ( std::list::iterator i = initializers.begin(); i != initializers.end(); i++ ) - (*i)->print( os, indent + 2 ); + for ( const Initializer * init : initializers ) { + init->print( os, indent + 2 ); + os << std::endl; + } } @@ -103,5 +110,5 @@ } -void ConstructorInit::print( std::ostream &os, int indent ) { +void ConstructorInit::print( std::ostream &os, int indent ) const { os << std::endl << std::string(indent, ' ') << "Constructor initializer: " << std::endl; if ( ctor ) { @@ -124,6 +131,19 @@ } -std::ostream & operator<<( std::ostream & out, Initializer * init ) { - init->print( out ); +std::ostream & operator<<( std::ostream & out, const Initializer * init ) { + if ( init ) { + init->print( out ); + } else { + out << "nullptr"; + } + return out; +} + +std::ostream & operator<<( std::ostream & out, const Designation * des ) { + if ( des ) { + des->print( out ); + } else { + out << "nullptr"; + } return out; } Index: src/SynTree/Initializer.h =================================================================== --- src/SynTree/Initializer.h (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/SynTree/Initializer.h (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -25,26 +25,29 @@ #include "Visitor.h" -const std::list noDesignators; +// Designation: list of designator (NameExpr, VariableExpr, and ConstantExpr) expressions that specify an object being initialized. +class Designation : public BaseSyntaxNode { +public: + Designation( const std::list< Expression * > & designators ); + Designation( const Designation & other ); + virtual ~Designation(); + + std::list< Expression * > & get_designators() { return designators; } + + virtual Designation * clone() const { return new Designation( *this ); }; + virtual void accept( Visitor &v ) { v.visit( this ); } + virtual Designation * acceptMutator( Mutator &m ) { return m.mutate( this ); } + virtual void print( std::ostream &os, int indent = 0 ) const; +private: + std::list< Expression * > designators; +}; + +const std::list noDesignators; // Initializer: base class for object initializers (provide default values) class Initializer : public BaseSyntaxNode { public: - // Initializer( std::string _name = std::string(""), int _pos = 0 ); Initializer( bool maybeConstructed ); Initializer( const Initializer & other ); virtual ~Initializer(); - - static std::string designator_name( Expression *designator ); - - // void set_name( std::string newValue ) { name = newValue; } - // std::string get_name() const { return name; } - - // void set_pos( int newValue ) { pos = newValue; } - // int get_pos() const { return pos; } - virtual void set_designators( std::list & ) { assert(false); } - virtual std::list &get_designators() { - assert(false); - std::list *ret = 0; return *ret; // never reached - } bool get_maybeConstructed() { return maybeConstructed; } @@ -53,8 +56,6 @@ virtual void accept( Visitor &v ) = 0; virtual Initializer *acceptMutator( Mutator &m ) = 0; - virtual void print( std::ostream &os, int indent = 0 ) = 0; + virtual void print( std::ostream &os, int indent = 0 ) const = 0; private: - // std::string name; - // int pos; bool maybeConstructed; }; @@ -63,5 +64,5 @@ class SingleInit : public Initializer { public: - SingleInit( Expression *value, const std::list< Expression *> &designators = std::list< Expression * >(), bool maybeConstructed = false ); + SingleInit( Expression *value, bool maybeConstructed = false ); SingleInit( const SingleInit &other ); virtual ~SingleInit(); @@ -70,15 +71,11 @@ void set_value( Expression *newValue ) { value = newValue; } - std::list &get_designators() { return designators; } - void set_designators( std::list &newValue ) { designators = newValue; } - virtual SingleInit *clone() const { return new SingleInit( *this); } virtual void accept( Visitor &v ) { v.visit( this ); } virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); } - virtual void print( std::ostream &os, int indent = 0 ); + virtual void print( std::ostream &os, int indent = 0 ) const; private: //Constant *value; Expression *value; // has to be a compile-time constant - std::list< Expression * > designators; }; @@ -88,24 +85,25 @@ public: ListInit( const std::list &initializers, - const std::list &designators = std::list< Expression * >(), bool maybeConstructed = false ); + const std::list &designators = {}, bool maybeConstructed = false ); ListInit( const ListInit & other ); virtual ~ListInit(); - void set_designators( std::list &newValue ) { designators = newValue; } - std::list &get_designators() { return designators; } - void set_initializers( std::list &newValue ) { initializers = newValue; } - std::list &get_initializers() { return initializers; } + std::list & get_designations() { return designations; } + std::list & get_initializers() { return initializers; } typedef std::list::iterator iterator; + typedef std::list::const_iterator const_iterator; iterator begin() { return initializers.begin(); } iterator end() { return initializers.end(); } + const_iterator begin() const { return initializers.begin(); } + const_iterator end() const { return initializers.end(); } virtual ListInit *clone() const { return new ListInit( *this ); } virtual void accept( Visitor &v ) { v.visit( this ); } virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); } - virtual void print( std::ostream &os, int indent = 0 ); + virtual void print( std::ostream &os, int indent = 0 ) const; private: - std::list initializers; // order *is* important - std::list designators; + std::list initializers; // order *is* important + std::list designations; // order/length is consistent with initializers }; @@ -130,5 +128,5 @@ virtual void accept( Visitor &v ) { v.visit( this ); } virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); } - virtual void print( std::ostream &os, int indent = 0 ); + virtual void print( std::ostream &os, int indent = 0 ) const; private: @@ -140,5 +138,6 @@ }; -std::ostream & operator<<( std::ostream & out, Initializer * init ); +std::ostream & operator<<( std::ostream & out, const Initializer * init ); +std::ostream & operator<<( std::ostream & out, const Designation * des ); #endif // INITIALIZER_H Index: src/SynTree/Mutator.cc =================================================================== --- src/SynTree/Mutator.cc (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/SynTree/Mutator.cc (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -433,4 +433,20 @@ } +Expression *Mutator::mutate( UntypedInitExpr * initExpr ) { + initExpr->set_env( maybeMutate( initExpr->get_env(), *this ) ); + initExpr->set_result( maybeMutate( initExpr->get_result(), *this ) ); + initExpr->set_expr( maybeMutate( initExpr->get_expr(), *this ) ); + // not currently mutating initAlts, but this doesn't matter since this node is only used in the resolver. + return initExpr; +} + +Expression *Mutator::mutate( InitExpr * initExpr ) { + initExpr->set_env( maybeMutate( initExpr->get_env(), *this ) ); + initExpr->set_result( maybeMutate( initExpr->get_result(), *this ) ); + initExpr->set_expr( maybeMutate( initExpr->get_expr(), *this ) ); + initExpr->set_designation( maybeMutate( initExpr->get_designation(), *this ) ); + return initExpr; +} + Type *Mutator::mutate( VoidType *voidType ) { @@ -499,4 +515,5 @@ mutateAll( tupleType->get_forall(), *this ); mutateAll( tupleType->get_types(), *this ); + mutateAll( tupleType->get_members(), *this ); return tupleType; } @@ -535,4 +552,9 @@ +Designation *Mutator::mutate( Designation * designation ) { + mutateAll( designation->get_designators(), *this ); + return designation; +} + Initializer *Mutator::mutate( SingleInit *singleInit ) { singleInit->set_value( singleInit->get_value()->acceptMutator( *this ) ); @@ -541,5 +563,5 @@ Initializer *Mutator::mutate( ListInit *listInit ) { - mutateAll( listInit->get_designators(), *this ); + mutateAll( listInit->get_designations(), *this ); mutateAll( listInit->get_initializers(), *this ); return listInit; Index: src/SynTree/Mutator.h =================================================================== --- src/SynTree/Mutator.h (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/SynTree/Mutator.h (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -85,4 +85,6 @@ virtual Expression* mutate( StmtExpr * stmtExpr ); virtual Expression* mutate( UniqueExpr * uniqueExpr ); + virtual Expression* mutate( UntypedInitExpr * initExpr ); + virtual Expression* mutate( InitExpr * initExpr ); virtual Type* mutate( VoidType *basicType ); @@ -103,4 +105,5 @@ virtual Type* mutate( OneType *oneType ); + virtual Designation* mutate( Designation *designation ); virtual Initializer* mutate( SingleInit *singleInit ); virtual Initializer* mutate( ListInit *listInit ); Index: src/SynTree/SynTree.h =================================================================== --- src/SynTree/SynTree.h (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/SynTree/SynTree.h (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -93,4 +93,6 @@ class StmtExpr; class UniqueExpr; +class UntypedInitExpr; +class InitExpr; class Type; @@ -113,4 +115,5 @@ class OneType; +class Designation; class Initializer; class SingleInit; Index: src/SynTree/TupleType.cc =================================================================== --- src/SynTree/TupleType.cc (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/SynTree/TupleType.cc (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -14,16 +14,31 @@ // +#include "Declaration.h" +#include "Initializer.h" #include "Type.h" #include "Common/utility.h" +#include "Parser/LinkageSpec.h" TupleType::TupleType( const Type::Qualifiers &tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), types( types ) { + for ( Type * t : *this ) { + // xxx - this is very awkward. TupleTypes should contain objects so that members can be named, but if they don't have an initializer node then + // they end up getting constructors, which end up being inserted causing problems. This happens because the object decls have to be visited so that + // their types are kept in sync with the types list here. Ultimately, the types list here should be eliminated and perhaps replaced with a list-view + // of the object types list, but I digress. The temporary solution here is to make a ListInit with maybeConstructed = false, that way even when the + // object is visited, it is never constructed. Ultimately, a better solution might be either: + // a) to separate TupleType from its declarations, into TupleDecl and Tuple{Inst?}Type, ala StructDecl and StructInstType + // b) separate initializer nodes better, e.g. add a MaybeConstructed node that is replaced by genInit, rather than what currently exists in a bool + members.push_back( new ObjectDecl( "" , Type::StorageClasses(), LinkageSpec::Cforall, nullptr, t->clone(), new ListInit( {}, {}, false ) ) ); + } } TupleType::TupleType( const TupleType& other ) : Type( other ) { cloneAll( other.types, types ); + cloneAll( other.members, members ); } TupleType::~TupleType() { deleteAll( types ); + deleteAll( members ); } Index: src/SynTree/Type.h =================================================================== --- src/SynTree/Type.h (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/SynTree/Type.h (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -481,5 +481,5 @@ class TupleType : public Type { public: - TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types = std::list< Type * >(), const std::list< Attribute * > & attributes = std::list< Attribute * >() ); + TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); TupleType( const TupleType& ); virtual ~TupleType(); @@ -488,6 +488,10 @@ typedef value_type::iterator iterator; - std::list& get_types() { return types; } + std::list & get_types() { return types; } virtual unsigned size() const { return types.size(); }; + + // For now, this is entirely synthetic -- tuple types always have unnamed members. + // Eventually, we may allow named tuples, in which case members should subsume types + std::list & get_members() { return members; } iterator begin() { return types.begin(); } @@ -506,5 +510,6 @@ virtual void print( std::ostream & os, int indent = 0 ) const; private: - std::list types; + std::list types; + std::list members; }; Index: src/SynTree/VarExprReplacer.cc =================================================================== --- src/SynTree/VarExprReplacer.cc (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/SynTree/VarExprReplacer.cc (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -14,14 +14,18 @@ // +#include "Declaration.h" #include "Expression.h" #include "VarExprReplacer.h" -VarExprReplacer::VarExprReplacer( const DeclMap & declMap ) : declMap( declMap ) {} +VarExprReplacer::VarExprReplacer( const DeclMap & declMap, bool debug ) : declMap( declMap ), debug( debug ) {} // 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() ) ); - } + // 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() ) ) { + if ( debug ) { + std::cerr << "replacing variable reference: " << (void*)varExpr->get_var() << " " << varExpr->get_var() << " with " << (void*)declMap.at( varExpr->get_var() ) << " " << declMap.at( varExpr->get_var() ) << std::endl; + } + varExpr->set_var( declMap.at( varExpr->get_var() ) ); + } } Index: src/SynTree/VarExprReplacer.h =================================================================== --- src/SynTree/VarExprReplacer.h (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/SynTree/VarExprReplacer.h (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -27,6 +27,7 @@ private: const DeclMap & declMap; + bool debug; public: - VarExprReplacer( const DeclMap & declMap ); + VarExprReplacer( const DeclMap & declMap, bool debug = false ); // replace variable with new node from decl map Index: src/SynTree/Visitor.cc =================================================================== --- src/SynTree/Visitor.cc (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/SynTree/Visitor.cc (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -340,4 +340,16 @@ } +void Visitor::visit( UntypedInitExpr * initExpr ) { + maybeAccept( initExpr->get_result(), *this ); + maybeAccept( initExpr->get_expr(), *this ); + // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver. +} + +void Visitor::visit( InitExpr * initExpr ) { + maybeAccept( initExpr->get_result(), *this ); + maybeAccept( initExpr->get_expr(), *this ); + maybeAccept( initExpr->get_designation(), *this ); +} + void Visitor::visit( VoidType *voidType ) { @@ -395,4 +407,5 @@ acceptAll( tupleType->get_forall(), *this ); acceptAll( tupleType->get_types(), *this ); + acceptAll( tupleType->get_members(), *this ); } @@ -424,4 +437,7 @@ } +void Visitor::visit( Designation * designation ) { + acceptAll( designation->get_designators(), *this ); +} void Visitor::visit( SingleInit *singleInit ) { @@ -430,5 +446,5 @@ void Visitor::visit( ListInit *listInit ) { - acceptAll( listInit->get_designators(), *this ); + acceptAll( listInit->get_designations(), *this ); acceptAll( listInit->get_initializers(), *this ); } Index: src/SynTree/Visitor.h =================================================================== --- src/SynTree/Visitor.h (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/SynTree/Visitor.h (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -88,4 +88,6 @@ virtual void visit( StmtExpr * stmtExpr ); virtual void visit( UniqueExpr * uniqueExpr ); + virtual void visit( UntypedInitExpr * initExpr ); + virtual void visit( InitExpr * initExpr ); virtual void visit( VoidType *basicType ); @@ -106,4 +108,5 @@ virtual void visit( OneType *oneType ); + virtual void visit( Designation *designation ); virtual void visit( SingleInit *singleInit ); virtual void visit( ListInit *listInit ); Index: src/Tuples/TupleExpansion.cc =================================================================== --- src/Tuples/TupleExpansion.cc (revision 1abc5ab5b96dec46ebfe0132b1fc3d15eddea566) +++ src/Tuples/TupleExpansion.cc (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -192,5 +192,5 @@ } ObjectDecl * finished = new ObjectDecl( toString( "_unq", id, "_finished_" ), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ), - new SingleInit( new ConstantExpr( Constant::from_int( 0 ) ), noDesignators ) ); + new SingleInit( new ConstantExpr( Constant::from_int( 0 ) ) ) ); addDeclaration( finished ); // (finished ? _unq_expr_N : (_unq_expr_N = get_expr()>, finished = 1, _unq_expr_N)) @@ -310,20 +310,19 @@ Type * makeTupleType( const std::list< Expression * > & exprs ) { // produce the TupleType which aggregates the types of the exprs - TupleType *tupleType = new TupleType( Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Lvalue | Type::Atomic | Type::Mutex ) ); - Type::Qualifiers &qualifiers = tupleType->get_qualifiers(); + std::list< Type * > types; + Type::Qualifiers qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Lvalue | Type::Atomic | Type::Mutex ); for ( Expression * expr : exprs ) { assert( expr->get_result() ); if ( expr->get_result()->isVoid() ) { // if the type of any expr is void, the type of the entire tuple is void - delete tupleType; return new VoidType( Type::Qualifiers() ); } Type * type = expr->get_result()->clone(); - tupleType->get_types().push_back( type ); + types.push_back( type ); // the qualifiers on the tuple type are the qualifiers that exist on all component types qualifiers &= type->get_qualifiers(); } // for if ( exprs.empty() ) qualifiers = Type::Qualifiers(); - return tupleType; + return new TupleType( qualifiers, types ); } Index: src/tests/.expect/designations.txt =================================================================== --- src/tests/.expect/designations.txt (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) +++ src/tests/.expect/designations.txt (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -0,0 +1,53 @@ +=====A===== +(A){ 2 3 (nil) } +(A){ 2 3 (nil) } +(A){ 0 3 (nil) } +=====A===== + +=====B===== +(B){ + (A){ 5 0 (nil) } + (A){ 0 0 (nil) } +} +(B){ + (A){ 5 2 (nil) } + (A){ 6 0 (nil) } +} +(B){ + (A){ 1 0 (nil) } + (A){ 2 3 (nil) } +} +(B){ + (A){ 1 2 (nil) } + (A){ 4 5 (nil) } +} +(B){ + (A){ 1 0 (nil) } + (A){ 2 3 (nil) } +} +(B){ + (A){ 1 0 (nil) } + (A){ 2 3 (nil) } +} +=====B===== + +=====C===== +(C){ + (int[]{ 2 3 4 } + (B){ + (A){ 5 6 (nil) } + (A){ 7 8 (nil) } + } +} +=====C===== + +=====E===== +(A){ 2 3 (nil) } +(A){ 2 3 (nil) } +(A){ 2 3 (nil) } +(B){ + (A){ 2 3 (nil) } + (A){ 5 6 (nil) } +} +=====E===== + Index: src/tests/designations.c =================================================================== --- src/tests/designations.c (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) +++ src/tests/designations.c (revision a12d5aaf574b9eda122e096ee19ea16b8f778731) @@ -0,0 +1,246 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// designations.c -- +// +// Author : Rob Schluntz +// Created On : Thu Jun 29 15:26:36 2017 +// Last Modified By : Rob Schluntz +// Last Modified On : Thu Jun 29 15:27:05 2017 +// Update Count : 2 +// + +// Note: this test case has been crafted so that it compiles with both cfa and with gcc without any modifications. +// In particular, since the syntax for designations in Cforall differs from that of C, preprocessor substitution +// is used for the designation syntax +#ifdef __CFORALL__ +#define DES : +#else +int printf(const char *, ...); +#define DES = +#endif + +const int indentAmt = 2; +void indent(int level) { + for (int i = 0; i < level; ++i) { + printf(" "); + } +} + +// A contains fields with different types (int vs. int *) +struct A { + int x, y; + int * ptr; +}; +void printA(struct A a, int level) { + indent(level); + printf("(A){ %d %d %p }\n", a.x, a.y, a.ptr); +} + +// B contains struct members +struct B { + struct A a0, a1; +}; +void printB(struct B b, int level) { + indent(level); + printf("(B){\n"); + printA(b.a0, level+indentAmt); + printA(b.a1, level+indentAmt); + indent(level); + printf("}\n"); +} + +// C contains an array - tests that after 3 ints, the members of B are initialized. +struct C { + int arr[3]; + struct B b; +}; +void printC(struct C c, int level) { + indent(level); + printf("(C){\n"); + indent(level+indentAmt); + printf("(int[]{ %d %d %d }\n", c.arr[0], c.arr[1], c.arr[2]); + printB(c.b, level+indentAmt); + indent(level); + printf("}\n"); +} + +// D contains an unnamed aggregate - tests that this doesn't interfere with initialization. +struct D { + struct { + int x; + }; +}; +void printD(struct D d, int level) { + indent(level); + printf("(D){ %d }\n", d.x); +} + +// E tests unions +union E { + struct A a; + struct B b; + struct C c; + struct D d; + int i; +}; + +int main() { + // simple designation case - starting from beginning of structure, leaves ptr default-initialized (zero) + struct A y0 = { + .x DES 2, + .y DES 3 + }; + + // simple initializaiton case - initialize all elements explicitly with no designations + struct A y1 = { + 2, 3, 0 + }; + + + // use designation to move to member y, leaving x default-initialized (zero) + struct A y2 = { + .y DES 3, + 0 + }; + +#if ERROR + struct A yErr0 = { + {} // error - empty scalar initializer is illegal + }; +#endif + + printf("=====A=====\n"); + printA(y0, 0); + printA(y1, 0); + printA(y2, 0); + printf("=====A=====\n\n"); + + // initialize only first element (z0.a.x), leaving everything else default-initialized (zero), no nested curly-braces + struct B z0 = { 5 }; + + // some nested curly braces, use designation to 'jump around' within structure, leaving some members default-initialized + struct B z1 = { + { 3 }, // z1.a0 + { 4 }, // z1.a1 + .a0 DES { 5 }, // z1.a0 + { 6 }, // z1.a1 + .a0.y DES 2, // z1.a0.y + 0, // z1.a0.ptr + }; + + // z2.a0.y and z2.a0.ptr default-initialized, everything else explicit + struct B z2 = { + { 1 }, + { 2, 3, 0 } + }; + + // initialize every member, omitting nested curly braces + struct B z3 = { + 1, 2, 0, 4, 5, 0 + }; + + // no initializer - legal C, but garbage values - don't print this one + struct B z4; + + // no curly braces - initialize with object of same type + struct B z5 = z2; + + // z6.a0.y and z6.a0.ptr default-initialized, everything else explicit. + // no curly braces on z6.a1 initializers + struct B z6 = { + { 1 }, + 2, 3, 0 + }; + + printf("=====B=====\n"); + printB(z0, 0); + printB(z1, 0); + printB(z2, 0); + printB(z3, 0); + printB(z5, 0); + printB(z6, 0); + printf("=====B=====\n\n"); + + // TODO: what about extra things in a nested init? are empty structs skipped?? + + // test that initializing 'past array bound' correctly moves to next member. + struct C c1 = { + 2, 3, 4, // arr + 5, 6, 0, // b.a0 + 7, 8, 0, // b.a1 + }; + + printf("=====C=====\n"); + printC(c1, 0); + printf("=====C=====\n\n"); + +#if ERROR + // nested initializer can't refer to same type in C + struct C cErr0 = { c1 }; + + // must use curly braces to initialize members + struct C cErr1 = 2; + + // can't initialize with array compound literal + struct C cErr2 = { + (int[3]) { 1, 2, 3 } // error: array initialized from non-constant array expression + }; +#endif + +#if WARNING + // can't initialize array with array - converts to int* + int cWarn0_arr[3] = { 1, 2, 3 }; + struct C cWarn0 = { + cWarn0_arr // warning: initialization makes integer from ptr without cast + }; +#endif + + // allowed to have 'too many' initialized lists - essentially they are ignored. + int i1 = { 3 }; + + // doesn't work yet. + // designate unnamed object's members + // struct D d = { .x DES 3 }; +#if ERROR + struct D d1 = { .y DES 3 }; +#endif + + // simple union initialization - initialized first member (e0.a) + union E e0 = { + y0 + }; + + // simple union initialization - initializes first member (e1.a) - with nested initializer list + union E e1 = { + { 2, 3, 0 } + }; + + // simple union initialization - initializes first member (e2.a) - without nested initializer list + union E e2 = { + 2, 3, 0 + }; + + // move cursor to e4.b.a0.x and initialize until e3.b.a1.ptr inclusive + union E e3 = { + .b.a0.x DES 2, 3, 0, 5, 6, 0 + }; + + printf("=====E=====\n"); + printA(e0.a, 0); + printA(e1.a, 0); + printA(e2.a, 0); + printB(e3.b, 0); + printf("=====E=====\n\n"); + + // special case of initialization: char[] can be initialized with a string literal + const char * str0 = "hello"; + char str1[] = "hello"; +} + +// Local Variables: // +// tab-width: 4 // +// End: //