Index: src/ResolvExpr/AlternativeFinder.cc =================================================================== --- src/ResolvExpr/AlternativeFinder.cc (revision 7e003011cac72e307c02d183bca9cbd4a982d69b) +++ src/ResolvExpr/AlternativeFinder.cc (revision e4d829bf54d5191b9e826c8c7fc40b7c7c7bc768) @@ -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; @@ -1182,4 +1182,43 @@ } + void AlternativeFinder::visit( UntypedInitExpr *initExpr ) { + AlternativeFinder finder( indexer, env ); + finder.findWithAdjustment( initExpr->get_expr() ); + // handle each option like a cast -- should probably push this info into AltFinder as a kind of expression, both to keep common code close and to have less 'reach-in', but more 'push-in' + AltList candidates; + std::cerr << "untyped init expr: " << initExpr << std::endl; + // O(N^2) checks of d-types with e-types + for ( Alternative & alt : finder.get_alternatives() ) { + for ( InitAlternative & initAlt : initExpr->get_initAlts() ) { + AssertionSet needAssertions, haveAssertions; + OpenVarSet openVars; + std::cerr << " " << initAlt.type << " " << 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() - initAlt.type->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( initAlt.type, alt.expr->get_result(), alt.env, needAssertions, haveAssertions, openVars, indexer ); + + Cost thisCost = castCost( alt.expr->get_result(), initAlt.type, indexer, alt.env ); + 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( alt.expr->clone(), initAlt.type->clone(), initAlt.designation->clone() ), alt.env, 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 7e003011cac72e307c02d183bca9cbd4a982d69b) +++ src/ResolvExpr/AlternativeFinder.h (revision e4d829bf54d5191b9e826c8c7fc40b7c7c7bc768) @@ -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 e4d829bf54d5191b9e826c8c7fc40b7c7c7bc768) +++ src/ResolvExpr/CurrentObject.cc (revision e4d829bf54d5191b9e826c8c7fc40b7c7c7bc768) @@ -0,0 +1,525 @@ +// +// 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" + +#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->get_kind() == BasicType::Char || basicType->get_kind() == BasicType::SignedChar || basicType->get_kind() == BasicType::UnsignedChar ) { + assertf( constExpr->get_constant()->get_value().size() == 3, "constant value with unusual length: %s", constExpr->get_constant()->get_value().c_str() ); + return constExpr->get_constant()->get_value()[1]; + } else { + return stoll( constExpr->get_constant()->get_value() ); + } + } else { + assertf( false, "unhandled type on getConstValue %s", constExpr->get_result() ); + } + } + + 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, ' '); + } + + 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 ); // 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 + PRINT( std::cerr << "array type with size: " << size << std::endl; ) + } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) { + setSize( castExpr->get_arg() ); + } else { + assertf( false, "unhandled expression in setSize: %s", toString( expr ).c_str() ); + } + } + + 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::iterator iterator; + const char * kind = ""; // for debug + ReferenceToType * inst = nullptr; + AggregateDecl * decl = nullptr; + iterator curMember; + bool atbegin = true; // false at first {small,big}Step -- this struct type is only added to the possibilities at the beginning + Type * curType = nullptr; + MemberIterator * memberIter = nullptr; + + AggregateIterator( const char * kind, ReferenceToType * inst, AggregateDecl * decl ) : kind( kind ), inst( inst ), decl( decl ), curMember( decl->get_members().begin() ) { + init(); + } + + virtual ~AggregateIterator() { + delete memberIter; + } + + bool init() { + PRINT( std::cerr << "--init()--" << std::endl; ) + if ( curMember != decl->get_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(); + 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 ) ) ); + } + 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 = decl->get_members().begin(); curMember != decl->get_members().end(); ++curMember ) { + if ( *curMember == varExpr->get_var() ) { + designators.pop_front(); + delete memberIter; + memberIter = createMemberIterator( varExpr->get_result() ); + curType = varExpr->get_result(); + atbegin = curMember == decl->get_members().begin() && designators.empty(); // xxx - is this right?? + memberIter->setPosition( designators ); + return; + } // if + } // for + assertf( false, "could not find member in %s: %s", kind, toString( varExpr ).c_str() ); + } else { + assertf( false, "bad designator given to %s: %s", kind, 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 << "(" << decl->get_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, inst->get_baseUnion() ) {} + + 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 = decl->get_members().end(); + return *this; + } + virtual std::list first() const { return std::list{}; } + }; + + class StructIterator : public AggregateIterator { + public: + StructIterator( StructInstType * inst ) : AggregateIterator( "StructIterator", inst, inst->get_baseStruct() ) {} + + virtual operator bool() const { return curMember != decl->get_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 != decl->get_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( false, "some other reftotype" ); + } + } else if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) { + return new ArrayIterator( at ); + } 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 ) { + // xxx - record types.front()? + 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(); + } +} // namespace ResolvExpr + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/ResolvExpr/CurrentObject.h =================================================================== --- src/ResolvExpr/CurrentObject.h (revision e4d829bf54d5191b9e826c8c7fc40b7c7c7bc768) +++ src/ResolvExpr/CurrentObject.h (revision e4d829bf54d5191b9e826c8c7fc40b7c7c7bc768) @@ -0,0 +1,57 @@ +// +// 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(); + + 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 7e003011cac72e307c02d183bca9cbd4a982d69b) +++ src/ResolvExpr/Resolver.cc (revision e4d829bf54d5191b9e826c8c7fc40b7c7c7bc768) @@ -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 ); @@ -369,206 +375,123 @@ } + template< typename Aggr > + void lookupDesignation( Aggr * aggr, const std::list< Expression > & designators ) { + + } + 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; - } - } - } - } - } // 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 - } + UntypedInitExpr * untyped = new UntypedInitExpr( singleInit->get_value(), currentObject.getOptions() ); + Expression * newExpr = findSingleExpression( untyped, *this ); + InitExpr * initExpr = safe_dynamic_cast< InitExpr * >( newExpr ); + singleInit->set_value( new CastExpr( initExpr->get_expr()->clone(), initExpr->get_result()->clone() ) ); + currentObject.setNext( initExpr->get_designation() ); + currentObject.increment(); + delete initExpr; + + // // check if initializing type is char[] + // if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) { + // if ( isCharType( at->get_base() ) ) { + // // check if the resolved type is char * + // if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) { + // if ( isCharType( pt->get_base() ) ) { + // // strip cast if we're initializing a char[] with a char *, e.g. char x[] = "hello"; + // CastExpr *ce = dynamic_cast< CastExpr * >( newExpr ); + // singleInit->set_value( ce->get_arg() ); + // ce->set_arg( NULL ); + // delete ce; + // } + // } + // } + // } + } + + // template< typename AggrInst > + // TypeSubstitution makeGenericSubstitution( AggrInst * inst ) { + // assert( inst ); + // assert( inst->get_baseParameters() ); + // std::list< TypeDecl * > baseParams = *inst->get_baseParameters(); + // std::list< Expression * > typeSubs = inst->get_parameters(); + // TypeSubstitution subs( baseParams.begin(), baseParams.end(), typeSubs.begin() ); + // return subs; + // } + + // ReferenceToType * isStructOrUnion( Type * type ) { + // if ( StructInstType * sit = dynamic_cast< StructInstType * >( type ) ) { + // return sit; + // } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( type ) ) { + // return uit; + // } + // return nullptr; + // } + + // void Resolver::resolveSingleAggrInit( Declaration * dcl, InitIterator & init, InitIterator & initEnd, TypeSubstitution sub ) { + // ObjectDecl * obj = dynamic_cast< ObjectDecl * >( dcl ); + // assert( obj ); + // // need to substitute for generic types, so that casts are to concrete types + // currentObject = obj->clone(); // xxx - delete this + // sub.apply( currentObject ); + + // try { + // if ( init == initEnd ) return; // stop when there are no more initializers + // (*init)->accept( *this ); + // ++init; // made it past an initializer + // } catch( SemanticError & ) { + // // need to delve deeper, if you can + // if ( ReferenceToType * type = isStructOrUnion( currentObject->get_type() ) ) { + // resolveAggrInit( type, init, initEnd ); + // } else { + // // member is not an aggregate type, so can't go any deeper + + // // might need to rethink what is being thrown + // throw; + // } // if + // } + // } + + // void Resolver::resolveAggrInit( ReferenceToType * inst, InitIterator & init, InitIterator & initEnd ) { + // if ( StructInstType * sit = dynamic_cast< StructInstType * >( inst ) ) { + // TypeSubstitution sub = makeGenericSubstitution( sit ); + // StructDecl * st = sit->get_baseStruct(); + // if(st->get_members().empty()) return; + // // want to resolve each initializer to the members of the struct, + // // but if there are more initializers than members we should stop + // list< Declaration * >::iterator it = st->get_members().begin(); + // for ( ; it != st->get_members().end(); ++it) { + // resolveSingleAggrInit( *it, init, initEnd, sub ); + // } + // } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( inst ) ) { + // TypeSubstitution sub = makeGenericSubstitution( uit ); + // UnionDecl * un = uit->get_baseUnion(); + // if(un->get_members().empty()) return; + // // only resolve to the first member of a union + // resolveSingleAggrInit( *un->get_members().begin(), init, initEnd, sub ); + // } // if + // } void Resolver::visit( ListInit * listInit ) { - 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 + 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()) ) { + Designation * des = std::get<0>(p); + Initializer * init = std::get<1>(p); + newDesignations.push_back( currentObject.findNext( des ) ); + init->accept( *this ); + } + listInit->get_designations() = newDesignations; // xxx - memory management + currentObject.exitListInit(); + + // } 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/module.mk =================================================================== --- src/ResolvExpr/module.mk (revision 7e003011cac72e307c02d183bca9cbd4a982d69b) +++ src/ResolvExpr/module.mk (revision e4d829bf54d5191b9e826c8c7fc40b7c7c7bc768) @@ -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