Index: src/InitTweak/FixInit.cc =================================================================== --- src/InitTweak/FixInit.cc (revision b6424d96bff612f23b49fac429887c0b6bc21a2f) +++ src/InitTweak/FixInit.cc (revision d88f256ade0eaa8dd3de01f0df046f5252ccb73e) @@ -33,4 +33,5 @@ #include "SymTab/Autogen.h" #include "GenPoly/PolyMutator.h" +#include "GenPoly/DeclMutator.h" #include "SynTree/AddStmtVisitor.h" #include "CodeGen/GenType.h" // for warnings @@ -216,4 +217,12 @@ SymTab::Indexer & indexer; }; + + class FixCtorExprs : public GenPoly::DeclMutator { + public: + /// expands ConstructorExpr nodes into comma expressions, using a temporary for the first argument + static void fix( std::list< Declaration * > & translationUnit ); + + virtual Expression * mutate( ConstructorExpr * ctorExpr ); + }; } // namespace @@ -221,4 +230,5 @@ // fixes ConstructorInit for global variables. should happen before fixInitializers. InitTweak::fixGlobalInit( translationUnit, filename, inLibrary ); + InsertImplicitCalls::insert( translationUnit ); @@ -231,4 +241,12 @@ GenStructMemberCalls::generate( translationUnit ); + // xxx - ctor expansion currently has to be after FixCopyCtors, because there is currently a + // hack in the way untyped assignments are generated, where the first argument cannot have + // its address taken because of the way codegeneration handles UntypedExpr vs. ApplicationExpr. + // Thus such assignment exprs must never pushed through expression resolution (and thus should + // not go through the FixCopyCtors pass), otherwise they will fail -- guaranteed. + // Also needs to happen after GenStructMemberCalls, since otherwise member constructors exprs + // don't look right, and a member can be constructed more than once. + FixCtorExprs::fix( translationUnit ); } @@ -283,4 +301,9 @@ throw warner.errors; } + } + + void FixCtorExprs::fix( std::list< Declaration * > & translationUnit ) { + FixCtorExprs fixer; + fixer.mutateDeclarationList( translationUnit ); } @@ -480,6 +503,5 @@ retExpr = deref; } // if - // xxx - might need to set env on retExpr... - // retExpr->set_env( env->clone() ); + retExpr->set_env( env->clone() ); return retExpr; } else { @@ -914,4 +936,28 @@ return safe_dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untypedExpr, indexer ) ); } + + Expression * FixCtorExprs::mutate( ConstructorExpr * ctorExpr ) { + static UniqueName tempNamer( "_tmp_ctor_expr" ); + assert( ctorExpr->get_results().size() == 1 ); + ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, ctorExpr->get_results().front()->clone(), nullptr ); + addDeclaration( tmp ); + + ApplicationExpr * callExpr = safe_dynamic_cast< ApplicationExpr * > ( ctorExpr->get_callExpr() ); + TypeSubstitution * env = ctorExpr->get_env(); + ctorExpr->set_callExpr( nullptr ); + ctorExpr->set_env( nullptr ); + + Expression *& firstArg = callExpr->get_args().front(); + UntypedExpr * assign = new UntypedExpr( new NameExpr( "?=?" ) ); + assign->get_args().push_back( new VariableExpr( tmp ) ); + assign->get_args().push_back( firstArg ); + cloneAll( ctorExpr->get_results(), assign->get_results() ); + firstArg = assign; + + CommaExpr * commaExpr = new CommaExpr( callExpr, new VariableExpr( tmp ) ); + commaExpr->set_env( env ); + delete ctorExpr; + return commaExpr; + } } // namespace } // namespace InitTweak Index: src/InitTweak/InitTweak.cc =================================================================== --- src/InitTweak/InitTweak.cc (revision b6424d96bff612f23b49fac429887c0b6bc21a2f) +++ src/InitTweak/InitTweak.cc (revision d88f256ade0eaa8dd3de01f0df046f5252ccb73e) @@ -358,5 +358,5 @@ template Expression *& callArg( CallExpr * callExpr, unsigned int pos ) { - if ( pos >= callExpr->get_args().size() ) assert( false && "asking for argument that doesn't exist. Return NULL/throw exception?" ); + if ( pos >= callExpr->get_args().size() ) assertf( false, "asking for argument that doesn't exist. Return NULL/throw exception?" ); for ( Expression *& arg : callExpr->get_args() ) { if ( pos == 0 ) return arg; @@ -373,5 +373,5 @@ return callArg( untypedExpr, pos ); } else { - assert( false && "Unexpected expression type passed to getCallArg" ); + assertf( false, "Unexpected expression type passed to getCallArg" ); } } @@ -388,5 +388,5 @@ return memberExpr->get_member()->get_name(); } else { - assert( false && "Unexpected expression type being called as a function in call expression" ); + assertf( false, "Unexpected expression type being called as a function in call expression" ); } } @@ -400,5 +400,5 @@ } else { std::cerr << expr << std::endl; - assert( false && "Unexpected expression type passed to getFunctionName" ); + assertf( false, "Unexpected expression type passed to getFunctionName" ); } } Index: src/Parser/parser.cc =================================================================== --- src/Parser/parser.cc (revision b6424d96bff612f23b49fac429887c0b6bc21a2f) +++ src/Parser/parser.cc (revision d88f256ade0eaa8dd3de01f0df046f5252ccb73e) @@ -5111,6 +5111,6 @@ { Token fn; - fn.str = new std::string( "?{}" ); // location undefined - (yyval.en) = new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( (yyvsp[(1) - (4)].en) )->set_last( (yyvsp[(3) - (4)].en) ) ) ); + fn.str = new std::string( "?{}" ); // location undefined - use location of '{'? + (yyval.en) = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( (yyvsp[(1) - (4)].en) )->set_last( (yyvsp[(3) - (4)].en) ) ) ) ); } break; Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision b6424d96bff612f23b49fac429887c0b6bc21a2f) +++ src/Parser/parser.yy (revision d88f256ade0eaa8dd3de01f0df046f5252ccb73e) @@ -389,6 +389,6 @@ { Token fn; - fn.str = new std::string( "?{}" ); // location undefined - $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ); + fn.str = new std::string( "?{}" ); // location undefined - use location of '{'? + $$ = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) ); } ; Index: src/ResolvExpr/AlternativeFinder.cc =================================================================== --- src/ResolvExpr/AlternativeFinder.cc (revision b6424d96bff612f23b49fac429887c0b6bc21a2f) +++ src/ResolvExpr/AlternativeFinder.cc (revision d88f256ade0eaa8dd3de01f0df046f5252ccb73e) @@ -197,5 +197,5 @@ } - void AlternativeFinder::find( Expression *expr, bool adjust ) { + void AlternativeFinder::find( Expression *expr, bool adjust, bool prune ) { expr->accept( *this ); if ( alternatives.empty() ) { @@ -207,24 +207,26 @@ } } - PRINT( - std::cerr << "alternatives before prune:" << std::endl; - printAlts( alternatives, std::cerr ); - ) - AltList::iterator oldBegin = alternatives.begin(); - pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ), indexer ); - if ( alternatives.begin() == oldBegin ) { - std::ostringstream stream; - stream << "Can't choose between alternatives for expression "; - expr->print( stream ); - stream << "Alternatives are:"; - AltList winners; - findMinCost( alternatives.begin(), alternatives.end(), back_inserter( winners ) ); - printAlts( winners, stream, 8 ); - throw SemanticError( stream.str() ); - } - alternatives.erase( oldBegin, alternatives.end() ); - PRINT( - std::cerr << "there are " << alternatives.size() << " alternatives after elimination" << std::endl; - ) + if ( prune ) { + PRINT( + std::cerr << "alternatives before prune:" << std::endl; + printAlts( alternatives, std::cerr ); + ) + AltList::iterator oldBegin = alternatives.begin(); + pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ), indexer ); + if ( alternatives.begin() == oldBegin ) { + std::ostringstream stream; + stream << "Can't choose between alternatives for expression "; + expr->print( stream ); + stream << "Alternatives are:"; + AltList winners; + findMinCost( alternatives.begin(), alternatives.end(), back_inserter( winners ) ); + printAlts( winners, stream, 8 ); + throw SemanticError( stream.str() ); + } + alternatives.erase( oldBegin, alternatives.end() ); + PRINT( + std::cerr << "there are " << alternatives.size() << " alternatives after elimination" << std::endl; + ) + } // Central location to handle gcc extension keyword for all expression types. @@ -234,10 +236,10 @@ } - void AlternativeFinder::findWithAdjustment( Expression *expr ) { - find( expr, true ); + void AlternativeFinder::findWithAdjustment( Expression *expr, bool prune ) { + find( expr, true, prune ); } template< typename StructOrUnionType > - void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const std::string &name ) { + void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string &name ) { std::list< Declaration* > members; aggInst->lookup( name, members ); @@ -760,7 +762,7 @@ if ( agg->expr->get_results().size() == 1 ) { if ( StructInstType *structInst = dynamic_cast< StructInstType* >( agg->expr->get_results().front() ) ) { - addAggMembers( structInst, agg->expr, agg->cost, memberExpr->get_member() ); + addAggMembers( structInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() ); } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( agg->expr->get_results().front() ) ) { - addAggMembers( unionInst, agg->expr, agg->cost, memberExpr->get_member() ); + addAggMembers( unionInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() ); } // if } // if @@ -789,7 +791,7 @@ renameTypes( alternatives.back().expr ); if ( StructInstType *structInst = dynamic_cast< StructInstType* >( (*i)->get_type() ) ) { - addAggMembers( structInst, &newExpr, Cost( 0, 0, 1 ), "" ); + addAggMembers( structInst, &newExpr, Cost( 0, 0, 1 ), env, "" ); } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( (*i)->get_type() ) ) { - addAggMembers( unionInst, &newExpr, Cost( 0, 0, 1 ), "" ); + addAggMembers( unionInst, &newExpr, Cost( 0, 0, 1 ), env, "" ); } // if } // for @@ -1012,4 +1014,14 @@ alternatives.push_back( Alternative( impCpCtorExpr->clone(), env, Cost::zero ) ); } + + void AlternativeFinder::visit( ConstructorExpr * ctorExpr ) { + AlternativeFinder finder( indexer, env ); + // don't prune here, since it's guaranteed all alternatives will have the same type + // (giving the alternatives different types is half of the point of ConstructorExpr nodes) + finder.findWithAdjustment( ctorExpr->get_callExpr(), false ); + for ( Alternative & alt : finder.alternatives ) { + alternatives.push_back( Alternative( new ConstructorExpr( alt.expr->clone() ), alt.env, alt.cost ) ); + } + } } // namespace ResolvExpr Index: src/ResolvExpr/AlternativeFinder.h =================================================================== --- src/ResolvExpr/AlternativeFinder.h (revision b6424d96bff612f23b49fac429887c0b6bc21a2f) +++ src/ResolvExpr/AlternativeFinder.h (revision d88f256ade0eaa8dd3de01f0df046f5252ccb73e) @@ -29,7 +29,7 @@ public: AlternativeFinder( const SymTab::Indexer &indexer, const TypeEnvironment &env ); - void find( Expression *expr, bool adjust = false ); + void find( Expression *expr, bool adjust = false, bool prune = true ); /// Calls find with the adjust flag set; adjustment turns array and function types into equivalent pointer types - void findWithAdjustment( Expression *expr ); + void findWithAdjustment( Expression *expr, bool prune = true ); AltList &get_alternatives() { return alternatives; } @@ -66,4 +66,5 @@ virtual void visit( TupleExpr *tupleExpr ); virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr ); + virtual void visit( ConstructorExpr * ctorExpr ); public: // xxx - temporary hack - should make Tuples::TupleAssignment a friend template< typename InputIterator, typename OutputIterator > @@ -72,5 +73,5 @@ private: /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member - template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const std::string &name ); + template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string &name ); /// Adds alternatives for offsetof expressions, given the base type and name of the member template< typename StructOrUnionType > void addOffsetof( StructOrUnionType *aggInst, const std::string &name ); Index: src/SymTab/Validate.cc =================================================================== --- src/SymTab/Validate.cc (revision b6424d96bff612f23b49fac429887c0b6bc21a2f) +++ src/SymTab/Validate.cc (revision d88f256ade0eaa8dd3de01f0df046f5252ccb73e) @@ -60,4 +60,5 @@ #include "ResolvExpr/typeops.h" #include +#include "InitTweak/InitTweak.h" #define debugPrint( x ) if ( doDebug ) { std::cout << x; } @@ -171,8 +172,8 @@ }; - class VerifyCtorDtor : public Visitor { + class VerifyCtorDtorAssign : public Visitor { public: - /// ensure that constructors and destructors have at least one - /// parameter, the first of which must be a pointer, and no + /// ensure that constructors, destructors, and assignment have at least one + /// parameter, the first of which must be a pointer, and that ctor/dtors have no /// return values. static void verify( std::list< Declaration * > &translationUnit ); @@ -202,5 +203,5 @@ compoundliteral.mutateDeclarationList( translationUnit ); acceptAll( translationUnit, pass3 ); - VerifyCtorDtor::verify( translationUnit ); + VerifyCtorDtorAssign::verify( translationUnit ); } @@ -687,22 +688,22 @@ } - void VerifyCtorDtor::verify( std::list< Declaration * > & translationUnit ) { - VerifyCtorDtor verifier; + void VerifyCtorDtorAssign::verify( std::list< Declaration * > & translationUnit ) { + VerifyCtorDtorAssign verifier; acceptAll( translationUnit, verifier ); } - void VerifyCtorDtor::visit( FunctionDecl * funcDecl ) { + void VerifyCtorDtorAssign::visit( FunctionDecl * funcDecl ) { FunctionType * funcType = funcDecl->get_functionType(); std::list< DeclarationWithType * > &returnVals = funcType->get_returnVals(); std::list< DeclarationWithType * > ¶ms = funcType->get_parameters(); - if ( funcDecl->get_name() == "?{}" || funcDecl->get_name() == "^?{}" ) { + if ( InitTweak::isCtorDtorAssign( funcDecl->get_name() ) ) { if ( params.size() == 0 ) { - throw SemanticError( "Constructors and destructors require at least one parameter ", funcDecl ); + throw SemanticError( "Constructors, destructors, and assignment functions require at least one parameter ", funcDecl ); } if ( ! dynamic_cast< PointerType * >( params.front()->get_type() ) ) { - throw SemanticError( "First parameter of a constructor or destructor must be a pointer ", funcDecl ); + throw SemanticError( "First parameter of a constructor, destructor, or assignment function must be a pointer ", funcDecl ); } - if ( returnVals.size() != 0 ) { + if ( InitTweak::isCtorDtor( funcDecl->get_name() ) && returnVals.size() != 0 ) { throw SemanticError( "Constructors and destructors cannot have explicit return values ", funcDecl ); } Index: src/SynTree/Expression.cc =================================================================== --- src/SynTree/Expression.cc (revision b6424d96bff612f23b49fac429887c0b6bc21a2f) +++ src/SynTree/Expression.cc (revision d88f256ade0eaa8dd3de01f0df046f5252ccb73e) @@ -28,4 +28,5 @@ #include "TypeSubstitution.h" #include "Common/utility.h" +#include "InitTweak/InitTweak.h" @@ -493,5 +494,5 @@ void ImplicitCopyCtorExpr::print( std::ostream &os, int indent ) const { - os << std::string( indent, ' ' ) << "Implicit Copy Constructor Expression: " << std::endl; + os << "Implicit Copy Constructor Expression: " << std::endl; assert( callExpr ); callExpr->print( os, indent + 2 ); @@ -503,4 +504,46 @@ } + +ConstructorExpr::ConstructorExpr( Expression * callExpr ) : callExpr( callExpr ) { + // allow resolver to type a constructor used as an expression as if it has the same type as its first argument + assert( callExpr ); + Expression * arg = InitTweak::getCallArg( callExpr, 0 ); + assert( arg ); + cloneAll( arg->get_results(), results ); +} + +ConstructorExpr::ConstructorExpr( const ConstructorExpr & other ) : Expression( other ), callExpr( maybeClone( other.callExpr ) ) { +} + +ConstructorExpr::~ConstructorExpr() { + delete callExpr; +} + +void ConstructorExpr::print( std::ostream &os, int indent ) const { + os << "Constructor Expression: " << std::endl; + assert( callExpr ); + os << std::string( indent+2, ' ' ); + callExpr->print( os, indent + 2 ); + Expression::print( os, indent ); +} + + +CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) { + add_result( type->clone() ); +} + +CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( maybeClone( other.type ) ), initializer( maybeClone( other.initializer ) ) {} + +CompoundLiteralExpr::~CompoundLiteralExpr() { + delete initializer; + delete type; +} + +void CompoundLiteralExpr::print( std::ostream &os, int indent ) const { + os << "Compound Literal Expression: " << std::endl; + if ( type ) type->print( os, indent + 2 ); + if ( initializer ) initializer->print( os, indent + 2 ); +} + UntypedValofExpr::UntypedValofExpr( const UntypedValofExpr & other ) : Expression( other ), body ( maybeClone( other.body ) ) {} @@ -511,22 +554,4 @@ if ( get_body() != 0 ) get_body()->print( os, indent + 2 ); -} - - -CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) { - add_result( type->clone() ); -} - -CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( maybeClone( other.type ) ), initializer( maybeClone( other.initializer ) ) {} - -CompoundLiteralExpr::~CompoundLiteralExpr() { - delete initializer; - delete type; -} - -void CompoundLiteralExpr::print( std::ostream &os, int indent ) const { - os << "Compound Literal Expression: " << std::endl; - if ( type ) type->print( os, indent + 2 ); - if ( initializer ) initializer->print( os, indent + 2 ); } Index: src/SynTree/Expression.h =================================================================== --- src/SynTree/Expression.h (revision b6424d96bff612f23b49fac429887c0b6bc21a2f) +++ src/SynTree/Expression.h (revision d88f256ade0eaa8dd3de01f0df046f5252ccb73e) @@ -595,4 +595,44 @@ }; +/// ConstructorExpr represents the use of a constructor in an expression context, e.g. int * x = malloc() { 5 }; +class ConstructorExpr : public Expression { +public: + ConstructorExpr( Expression * callExpr ); + ConstructorExpr( const ConstructorExpr & other ); + ~ConstructorExpr(); + + Expression *get_callExpr() const { return callExpr; } + void set_callExpr( Expression *newValue ) { callExpr = newValue; } + + virtual ConstructorExpr *clone() const { return new ConstructorExpr( *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 * callExpr; +}; + +/// CompoundLiteralExpr represents a C99 'compound literal' +class CompoundLiteralExpr : public Expression { + public: + CompoundLiteralExpr( Type * type, Initializer * initializer ); + CompoundLiteralExpr( const CompoundLiteralExpr &other ); + ~CompoundLiteralExpr(); + + Type * get_type() const { return type; } + void set_type( Type * t ) { type = t; } + + Initializer * get_initializer() const { return initializer; } + void set_initializer( Initializer * i ) { initializer = i; } + + virtual CompoundLiteralExpr *clone() const { return new CompoundLiteralExpr( *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: + Type * type; + Initializer * initializer; +}; + /// ValofExpr represents a GCC 'lambda expression' class UntypedValofExpr : public Expression { @@ -613,26 +653,5 @@ }; -/// CompoundLiteralExpr represents a C99 'compound literal' -class CompoundLiteralExpr : public Expression { - public: - CompoundLiteralExpr( Type * type, Initializer * initializer ); - CompoundLiteralExpr( const CompoundLiteralExpr &other ); - ~CompoundLiteralExpr(); - - Type * get_type() const { return type; } - void set_type( Type * t ) { type = t; } - - Initializer * get_initializer() const { return initializer; } - void set_initializer( Initializer * i ) { initializer = i; } - - virtual CompoundLiteralExpr *clone() const { return new CompoundLiteralExpr( *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: - Type * type; - Initializer * initializer; -}; - +/// RangeExpr represents a range e.g. '3 ... 5' or '1~10' class RangeExpr : public Expression { public: Index: src/SynTree/Mutator.cc =================================================================== --- src/SynTree/Mutator.cc (revision b6424d96bff612f23b49fac429887c0b6bc21a2f) +++ src/SynTree/Mutator.cc (revision d88f256ade0eaa8dd3de01f0df046f5252ccb73e) @@ -339,7 +339,8 @@ } -Expression *Mutator::mutate( UntypedValofExpr *valofExpr ) { - mutateAll( valofExpr->get_results(), *this ); - return valofExpr; +Expression* Mutator::mutate( ConstructorExpr *ctorExpr ) { + mutateAll( ctorExpr->get_results(), *this ); + ctorExpr->set_callExpr( maybeMutate( ctorExpr->get_callExpr(), *this ) ); + return ctorExpr; } @@ -349,4 +350,9 @@ compLitExpr->set_initializer( maybeMutate( compLitExpr->get_initializer(), *this ) ); return compLitExpr; +} + +Expression *Mutator::mutate( UntypedValofExpr *valofExpr ) { + mutateAll( valofExpr->get_results(), *this ); + return valofExpr; } Index: src/SynTree/Mutator.h =================================================================== --- src/SynTree/Mutator.h (revision b6424d96bff612f23b49fac429887c0b6bc21a2f) +++ src/SynTree/Mutator.h (revision d88f256ade0eaa8dd3de01f0df046f5252ccb73e) @@ -76,6 +76,7 @@ virtual Expression* mutate( AsmExpr *asmExpr ); virtual Expression* mutate( ImplicitCopyCtorExpr *impCpCtorExpr ); + virtual Expression* mutate( ConstructorExpr *ctorExpr ); + virtual Expression* mutate( CompoundLiteralExpr *compLitExpr ); virtual Expression* mutate( UntypedValofExpr *valofExpr ); - virtual Expression* mutate( CompoundLiteralExpr *compLitExpr ); virtual Expression* mutate( RangeExpr *rangeExpr ); Index: src/SynTree/SynTree.h =================================================================== --- src/SynTree/SynTree.h (revision b6424d96bff612f23b49fac429887c0b6bc21a2f) +++ src/SynTree/SynTree.h (revision d88f256ade0eaa8dd3de01f0df046f5252ccb73e) @@ -81,6 +81,7 @@ class AsmExpr; class ImplicitCopyCtorExpr; +class ConstructorExpr; +class CompoundLiteralExpr; class UntypedValofExpr; -class CompoundLiteralExpr; class RangeExpr; Index: src/SynTree/Visitor.cc =================================================================== --- src/SynTree/Visitor.cc (revision b6424d96bff612f23b49fac429887c0b6bc21a2f) +++ src/SynTree/Visitor.cc (revision d88f256ade0eaa8dd3de01f0df046f5252ccb73e) @@ -287,7 +287,7 @@ } -void Visitor::visit( UntypedValofExpr *valofExpr ) { - acceptAll( valofExpr->get_results(), *this ); - maybeAccept( valofExpr->get_body(), *this ); +void Visitor::visit( ConstructorExpr * ctorExpr ) { + acceptAll( ctorExpr->get_results(), *this ); + maybeAccept( ctorExpr->get_callExpr(), *this ); } @@ -296,4 +296,9 @@ maybeAccept( compLitExpr->get_type(), *this ); maybeAccept( compLitExpr->get_initializer(), *this ); +} + +void Visitor::visit( UntypedValofExpr *valofExpr ) { + acceptAll( valofExpr->get_results(), *this ); + maybeAccept( valofExpr->get_body(), *this ); } Index: src/SynTree/Visitor.h =================================================================== --- src/SynTree/Visitor.h (revision b6424d96bff612f23b49fac429887c0b6bc21a2f) +++ src/SynTree/Visitor.h (revision d88f256ade0eaa8dd3de01f0df046f5252ccb73e) @@ -76,6 +76,7 @@ virtual void visit( AsmExpr *asmExpr ); virtual void visit( ImplicitCopyCtorExpr *impCpCtorExpr ); + virtual void visit( ConstructorExpr * ctorExpr ); + virtual void visit( CompoundLiteralExpr *compLitExpr ); virtual void visit( UntypedValofExpr *valofExpr ); - virtual void visit( CompoundLiteralExpr *compLitExpr ); virtual void visit( RangeExpr *rangeExpr ); Index: src/include/assert.h =================================================================== --- src/include/assert.h (revision b6424d96bff612f23b49fac429887c0b6bc21a2f) +++ src/include/assert.h (revision d88f256ade0eaa8dd3de01f0df046f5252ccb73e) @@ -22,5 +22,5 @@ #define assertf(expr, fmt, ...) ((expr) ? static_cast(0) : __assert_fail_f(__VSTRINGIFY__(expr), __FILE__, __LINE__, __PRETTY_FUNCTION__, fmt, ## __VA_ARGS__ )) -void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... ); +void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... ) __attribute__((noreturn)); template Index: src/libcfa/prelude.cf =================================================================== --- src/libcfa/prelude.cf (revision b6424d96bff612f23b49fac429887c0b6bc21a2f) +++ src/libcfa/prelude.cf (revision d88f256ade0eaa8dd3de01f0df046f5252ccb73e) @@ -636,62 +636,62 @@ // default ctor -void ?{}( _Bool * ), ?{}( volatile _Bool * ); -void ?{}( char * ), ?{}( volatile char * ); -void ?{}( unsigned char * ), ?{}( volatile unsigned char * ); -void ?{}( char signed * ), ?{}( volatile char signed * ); -void ?{}( int short * ), ?{}( volatile int short * ); -void ?{}( int short unsigned * ), ?{}( volatile int short unsigned * ); -void ?{}( signed int * ), ?{}( volatile signed int * ); -void ?{}( unsigned int * ), ?{}( volatile unsigned int * ); -void ?{}( signed long int * ), ?{}( volatile signed long int * ); -void ?{}( unsigned long int * ), ?{}( volatile unsigned long int * ); -void ?{}( signed long long int * ), ?{}( volatile signed long long int * ); -void ?{}( unsigned long long int * ), ?{}( volatile unsigned long long int * ); -void ?{}( float * ), ?{}( volatile float * ); -void ?{}( double * ), ?{}( volatile double * ); -void ?{}( long double * ), ?{}( volatile long double * ); -void ?{}( float _Complex * ), ?{}( volatile float _Complex * ); -void ?{}( double _Complex * ), ?{}( volatile double _Complex * ); -void ?{}( long double _Complex * ), ?{}( volatile long double _Complex * ); +void ?{}( _Bool * ); +void ?{}( char * ); +void ?{}( unsigned char * ); +void ?{}( char signed * ); +void ?{}( int short * ); +void ?{}( int short unsigned * ); +void ?{}( signed int * ); +void ?{}( unsigned int * ); +void ?{}( signed long int * ); +void ?{}( unsigned long int * ); +void ?{}( signed long long int * ); +void ?{}( unsigned long long int * ); +void ?{}( float * ); +void ?{}( double * ); +void ?{}( long double * ); +void ?{}( float _Complex * ); +void ?{}( double _Complex * ); +void ?{}( long double _Complex * ); // copy ctor -void ?{}( _Bool *, _Bool ), ?{}( volatile _Bool *, _Bool ); -void ?{}( char *, char ), ?{}( volatile char *, char ); -void ?{}( unsigned char *, unsigned char ), ?{}( volatile unsigned char *, unsigned char ); -void ?{}( char signed *, char signed ), ?{}( volatile char signed *, char signed ); -void ?{}( int short *, int short ), ?{}( volatile int short *, int short ); -void ?{}( int short unsigned *, int short unsigned ), ?{}( volatile int short unsigned *, int short unsigned ); -void ?{}( signed int *, signed int), ?{}( volatile signed int *, signed int ); -void ?{}( unsigned int *, unsigned int), ?{}( volatile unsigned int *, unsigned int ); -void ?{}( signed long int *, signed long int), ?{}( volatile signed long int *, signed long int ); -void ?{}( unsigned long int *, unsigned long int), ?{}( volatile unsigned long int *, unsigned long int ); -void ?{}( signed long long int *, signed long long int), ?{}( volatile signed long long int *, signed long long int ); -void ?{}( unsigned long long int *, unsigned long long int), ?{}( volatile unsigned long long int *, unsigned long long int ); -void ?{}( float *, float), ?{}( volatile float *, float ); -void ?{}( double *, double), ?{}( volatile double *, double ); -void ?{}( long double *, long double), ?{}( volatile long double *, long double ); -void ?{}( float _Complex *, float _Complex), ?{}( volatile float _Complex *, float _Complex ); -void ?{}( double _Complex *, double _Complex), ?{}( volatile double _Complex *, double _Complex ); -void ?{}( long double _Complex *, long double _Complex), ?{}( volatile long double _Complex *, long double _Complex ); +void ?{}( _Bool *, _Bool ); +void ?{}( char *, char ); +void ?{}( unsigned char *, unsigned char ); +void ?{}( char signed *, char signed ); +void ?{}( int short *, int short ); +void ?{}( int short unsigned *, int short unsigned ); +void ?{}( signed int *, signed int); +void ?{}( unsigned int *, unsigned int); +void ?{}( signed long int *, signed long int); +void ?{}( unsigned long int *, unsigned long int); +void ?{}( signed long long int *, signed long long int); +void ?{}( unsigned long long int *, unsigned long long int); +void ?{}( float *, float); +void ?{}( double *, double); +void ?{}( long double *, long double); +void ?{}( float _Complex *, float _Complex); +void ?{}( double _Complex *, double _Complex); +void ?{}( long double _Complex *, long double _Complex); // dtor -void ^?{}( _Bool * ), ^?{}( volatile _Bool * ); -void ^?{}( char * ), ^?{}( volatile char * ); -void ^?{}( char unsigned * ), ^?{}( volatile char unsigned * ); -void ^?{}( char signed * ), ^?{}( volatile char signed * ); -void ^?{}( int short * ), ^?{}( volatile int short * ); -void ^?{}( int short unsigned * ), ^?{}( volatile int short unsigned * ); -void ^?{}( signed int * ), ^?{}( volatile signed int * ); -void ^?{}( unsigned int * ), ^?{}( volatile unsigned int * ); -void ^?{}( signed long int * ), ^?{}( volatile signed long int * ); -void ^?{}( unsigned long int * ), ^?{}( volatile unsigned long int * ); -void ^?{}( signed long long int * ), ^?{}( volatile signed long long int * ); -void ^?{}( unsigned long long int * ), ^?{}( volatile unsigned long long int * ); -void ^?{}( float * ), ^?{}( volatile float * ); -void ^?{}( double * ), ^?{}( volatile double * ); -void ^?{}( long double * ), ^?{}( volatile long double * ); -void ^?{}( float _Complex * ), ^?{}( volatile float _Complex * ); -void ^?{}( double _Complex * ), ^?{}( volatile double _Complex * ); -void ^?{}( long double _Complex * ), ^?{}( volatile long double _Complex * ); +void ^?{}( _Bool * ); +void ^?{}( char * ); +void ^?{}( char unsigned * ); +void ^?{}( char signed * ); +void ^?{}( int short * ); +void ^?{}( int short unsigned * ); +void ^?{}( signed int * ); +void ^?{}( unsigned int * ); +void ^?{}( signed long int * ); +void ^?{}( unsigned long int * ); +void ^?{}( signed long long int * ); +void ^?{}( unsigned long long int * ); +void ^?{}( float * ); +void ^?{}( double * ); +void ^?{}( long double * ); +void ^?{}( float _Complex * ); +void ^?{}( double _Complex * ); +void ^?{}( long double _Complex * ); // // default ctor @@ -719,136 +719,79 @@ forall( dtype DT ) void ?{}( DT * *, DT * ); -forall( dtype DT ) void ?{}( DT * volatile *, DT * ); forall( dtype DT ) void ?{}( const DT * *, DT * ); -forall( dtype DT ) void ?{}( const DT * volatile *, DT * ); forall( dtype DT ) void ?{}( const DT * *, const DT * ); -forall( dtype DT ) void ?{}( const DT * volatile *, const DT * ); forall( dtype DT ) void ?{}( volatile DT * *, DT * ); -forall( dtype DT ) void ?{}( volatile DT * volatile *, DT * ); forall( dtype DT ) void ?{}( volatile DT * *, volatile DT * ); -forall( dtype DT ) void ?{}( volatile DT * volatile *, volatile DT * ); forall( dtype DT ) void ?{}( const volatile DT * *, DT * ); -forall( dtype DT ) void ?{}( const volatile DT * volatile *, DT * ); forall( dtype DT ) void ?{}( const volatile DT * *, const DT * ); -forall( dtype DT ) void ?{}( const volatile DT * volatile *, const DT * ); forall( dtype DT ) void ?{}( const volatile DT * *, volatile DT * ); -forall( dtype DT ) void ?{}( const volatile DT * volatile *, volatile DT * ); forall( dtype DT ) void ?{}( const volatile DT * *, const volatile DT * ); -forall( dtype DT ) void ?{}( const volatile DT * volatile *, const volatile DT * ); forall( dtype DT ) void ?{}( DT * *, void * ); -forall( dtype DT ) void ?{}( DT * volatile *, void * ); forall( dtype DT ) void ?{}( const DT * *, void * ); -forall( dtype DT ) void ?{}( const DT * volatile *, void * ); forall( dtype DT ) void ?{}( const DT * *, const void * ); -forall( dtype DT ) void ?{}( const DT * volatile *, const void * ); forall( dtype DT ) void ?{}( volatile DT * *, void * ); -forall( dtype DT ) void ?{}( volatile DT * volatile *, void * ); forall( dtype DT ) void ?{}( volatile DT * *, volatile void * ); -forall( dtype DT ) void ?{}( volatile DT * volatile *, volatile void * ); forall( dtype DT ) void ?{}( const volatile DT * *, void * ); -forall( dtype DT ) void ?{}( const volatile DT * volatile *, void * ); forall( dtype DT ) void ?{}( const volatile DT * *, const void * ); -forall( dtype DT ) void ?{}( const volatile DT * volatile *, const void * ); forall( dtype DT ) void ?{}( const volatile DT * *, volatile void * ); -forall( dtype DT ) void ?{}( const volatile DT * volatile *, volatile void * ); forall( dtype DT ) void ?{}( const volatile DT * *, const volatile void * ); -forall( dtype DT ) void ?{}( const volatile DT * volatile *, const volatile void * ); forall( dtype DT ) void ?{}( void * *, DT * ); -forall( dtype DT ) void ?{}( void * volatile *, DT * ); forall( dtype DT ) void ?{}( const void * *, DT * ); -forall( dtype DT ) void ?{}( const void * volatile *, DT * ); forall( dtype DT ) void ?{}( const void * *, const DT * ); -forall( dtype DT ) void ?{}( const void * volatile *, const DT * ); forall( dtype DT ) void ?{}( volatile void * *, DT * ); -forall( dtype DT ) void ?{}( volatile void * volatile *, DT * ); forall( dtype DT ) void ?{}( volatile void * *, volatile DT * ); -forall( dtype DT ) void ?{}( volatile void * volatile *, volatile DT * ); forall( dtype DT ) void ?{}( const volatile void * *, DT * ); -forall( dtype DT ) void ?{}( const volatile void * volatile *, DT * ); forall( dtype DT ) void ?{}( const volatile void * *, const DT * ); -forall( dtype DT ) void ?{}( const volatile void * volatile *, const DT * ); forall( dtype DT ) void ?{}( const volatile void * *, volatile DT * ); -forall( dtype DT ) void ?{}( const volatile void * volatile *, volatile DT * ); forall( dtype DT ) void ?{}( const volatile void * *, const volatile DT * ); -forall( dtype DT ) void ?{}( const volatile void * volatile *, const volatile DT * ); void ?{}( void * *, void * ); -void ?{}( void * volatile *, void * ); void ?{}( const void * *, void * ); -void ?{}( const void * volatile *, void * ); void ?{}( const void * *, const void * ); -void ?{}( const void * volatile *, const void * ); void ?{}( volatile void * *, void * ); -void ?{}( volatile void * volatile *, void * ); void ?{}( volatile void * *, volatile void * ); -void ?{}( volatile void * volatile *, volatile void * ); void ?{}( const volatile void * *, void * ); -void ?{}( const volatile void * volatile *, void * ); void ?{}( const volatile void * *, const void * ); -void ?{}( const volatile void * volatile *, const void * ); void ?{}( const volatile void * *, volatile void * ); -void ?{}( const volatile void * volatile *, volatile void * ); void ?{}( const volatile void * *, const volatile void * ); -void ?{}( const volatile void * volatile *, const volatile void * ); //forall( dtype DT ) void ?{}( DT * *, forall( dtype DT2 ) const DT2 * ); //forall( dtype DT ) void ?{}( DT * volatile *, forall( dtype DT2 ) const DT2 * ); forall( dtype DT ) void ?{}( const DT * *, forall( dtype DT2 ) const DT2 * ); -forall( dtype DT ) void ?{}( const DT * volatile *, forall( dtype DT2 ) const DT2 * ); //forall( dtype DT ) void ?{}( volatile DT * *, forall( dtype DT2 ) const DT2 * ); //forall( dtype DT ) void ?{}( volatile DT * volatile *, forall( dtype DT2 ) const DT2 * ); forall( dtype DT ) void ?{}( const volatile DT * *, forall( dtype DT2 ) const DT2 * ); -forall( dtype DT ) void ?{}( const volatile DT * volatile *, forall( dtype DT2 ) const DT2 * ); forall( ftype FT ) void ?{}( FT * *, forall( ftype FT2 ) FT2 * ); -forall( ftype FT ) void ?{}( FT * volatile *, forall( ftype FT2 ) FT2 * ); // default ctors forall( ftype FT ) void ?{}( FT * * ); -forall( ftype FT ) void ?{}( FT * volatile * ); forall( dtype DT ) void ?{}( DT * *); -forall( dtype DT ) void ?{}( DT * volatile *); forall( dtype DT ) void ?{}( const DT * *); -forall( dtype DT ) void ?{}( const DT * volatile *); forall( dtype DT ) void ?{}( volatile DT * *); -forall( dtype DT ) void ?{}( volatile DT * volatile *); forall( dtype DT ) void ?{}( const volatile DT * *); -forall( dtype DT ) void ?{}( const volatile DT * volatile *); void ?{}( void * *); -void ?{}( void * volatile *); void ?{}( const void * *); -void ?{}( const void * volatile *); void ?{}( volatile void * *); -void ?{}( volatile void * volatile *); void ?{}( const volatile void * *); -void ?{}( const volatile void * volatile *); // dtors forall( ftype FT ) void ^?{}( FT * * ); -forall( ftype FT ) void ^?{}( FT * volatile * ); forall( dtype DT ) void ^?{}( DT * *); -forall( dtype DT ) void ^?{}( DT * volatile *); forall( dtype DT ) void ^?{}( const DT * *); -forall( dtype DT ) void ^?{}( const DT * volatile *); forall( dtype DT ) void ^?{}( volatile DT * *); -forall( dtype DT ) void ^?{}( volatile DT * volatile *); forall( dtype DT ) void ^?{}( const volatile DT * *); -forall( dtype DT ) void ^?{}( const volatile DT * volatile *); void ^?{}( void * *); -void ^?{}( void * volatile *); void ^?{}( const void * *); -void ^?{}( const void * volatile *); void ^?{}( volatile void * *); -void ^?{}( volatile void * volatile *); void ^?{}( const volatile void * *); -void ^?{}( const volatile void * volatile *); // Local Variables: //