Index: src/Parser/LinkageSpec.cc =================================================================== --- src/Parser/LinkageSpec.cc (revision 258eb5c9477f29166b1ae9152e4dfdd2443eac84) +++ src/Parser/LinkageSpec.cc (revision 63afee01b295cdf30409284a0c1d8f6f5d5b1049) @@ -9,7 +9,7 @@ // Author : Rodolfo G. Esteves // Created On : Sat May 16 13:22:09 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sat May 16 13:23:21 2015 -// Update Count : 2 +// Last Modified By : Rob Schluntz +// Last Modified On : Wed Aug 19 15:53:05 2015 +// Update Count : 5 // @@ -79,4 +79,19 @@ } + +bool LinkageSpec::isOverridable( Type t ) { + switch ( t ) { + case Intrinsic: + case AutoGen: + return true; + case Cforall: + case C: + case Compiler: + return false; + } + assert( false ); + return false; +} + bool LinkageSpec::isBuiltin( Type t ) { switch ( t ) { Index: src/Parser/LinkageSpec.h =================================================================== --- src/Parser/LinkageSpec.h (revision 258eb5c9477f29166b1ae9152e4dfdd2443eac84) +++ src/Parser/LinkageSpec.h (revision 63afee01b295cdf30409284a0c1d8f6f5d5b1049) @@ -9,7 +9,7 @@ // Author : Rodolfo G. Esteves // Created On : Sat May 16 13:24:28 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sat May 16 13:26:14 2015 -// Update Count : 3 +// Last Modified By : Rob Schluntz +// Last Modified On : Tue Aug 18 14:11:55 2015 +// Update Count : 5 // @@ -34,4 +34,5 @@ static bool isGeneratable( Type ); static bool isOverloadable( Type ); + static bool isOverridable( Type ); static bool isBuiltin( Type ); }; Index: src/ResolvExpr/CastCost.cc =================================================================== --- src/ResolvExpr/CastCost.cc (revision 258eb5c9477f29166b1ae9152e4dfdd2443eac84) +++ src/ResolvExpr/CastCost.cc (revision 63afee01b295cdf30409284a0c1d8f6f5d5b1049) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Sun May 17 06:57:43 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sun May 17 06:59:10 2015 -// Update Count : 2 +// Last Modified By : Rob Schluntz +// Last Modified On : Mon Oct 05 14:48:45 2015 +// Update Count : 5 // @@ -56,4 +56,5 @@ return Cost::infinity; } else { + // xxx - why are we adding cost 0 here? return converter.get_cost() + Cost( 0, 0, 0 ); } // if @@ -82,8 +83,8 @@ newEnv.add( pointerType->get_forall() ); newEnv.add( pointerType->get_base()->get_forall() ); - int assignResult = ptrsCastable( pointerType->get_base(), destAsPtr->get_base(), newEnv, indexer ); - if ( assignResult > 0 ) { + int castResult = ptrsCastable( pointerType->get_base(), destAsPtr->get_base(), newEnv, indexer ); + if ( castResult > 0 ) { cost = Cost( 0, 0, 1 ); - } else if ( assignResult < 0 ) { + } else if ( castResult < 0 ) { cost = Cost( 1, 0, 0 ); } // if Index: src/ResolvExpr/PtrsAssignable.cc =================================================================== --- src/ResolvExpr/PtrsAssignable.cc (revision 258eb5c9477f29166b1ae9152e4dfdd2443eac84) +++ src/ResolvExpr/PtrsAssignable.cc (revision 63afee01b295cdf30409284a0c1d8f6f5d5b1049) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Sun May 17 11:44:11 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sun May 17 11:47:36 2015 -// Update Count : 2 +// Last Modified By : Rob Schluntz +// Last Modified On : Mon Sep 21 14:34:58 2015 +// Update Count : 7 // @@ -106,5 +106,5 @@ void PtrsAssignable::visit( TypeInstType *inst ) { EqvClass eqvClass; - if ( env.lookup( inst->get_name(), eqvClass ) ) { + if ( env.lookup( inst->get_name(), eqvClass ) && eqvClass.type ) { result = ptrsAssignable( eqvClass.type, dest, env ); } else { Index: src/ResolvExpr/PtrsCastable.cc =================================================================== --- src/ResolvExpr/PtrsCastable.cc (revision 258eb5c9477f29166b1ae9152e4dfdd2443eac84) +++ src/ResolvExpr/PtrsCastable.cc (revision 63afee01b295cdf30409284a0c1d8f6f5d5b1049) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Sun May 17 11:48:00 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sun May 17 11:51:17 2015 -// Update Count : 2 +// Last Modified By : Rob Schluntz +// Last Modified On : Mon Oct 05 14:49:12 2015 +// Update Count : 7 // @@ -133,5 +133,5 @@ void PtrsCastable::visit(TypeInstType *inst) { - result = objectCast( inst, env, indexer ) && objectCast( dest, env, indexer ) ? 1 : -1; + result = objectCast( inst, env, indexer ) > 0 && objectCast( dest, env, indexer ) > 0 ? 1 : -1; } Index: src/ResolvExpr/Unify.cc =================================================================== --- src/ResolvExpr/Unify.cc (revision 258eb5c9477f29166b1ae9152e4dfdd2443eac84) +++ src/ResolvExpr/Unify.cc (revision 63afee01b295cdf30409284a0c1d8f6f5d5b1049) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Sun May 17 12:27:10 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Fri Jun 26 14:57:05 2015 -// Update Count : 7 +// Last Modified By : Rob Schluntz +// Last Modified On : Wed Sep 02 14:43:22 2015 +// Update Count : 36 // @@ -28,5 +28,5 @@ -//#define DEBUG +// #define DEBUG namespace ResolvExpr { @@ -80,9 +80,15 @@ bool typesCompatible( Type *first, Type *second, const SymTab::Indexer &indexer, const TypeEnvironment &env ) { TypeEnvironment newEnv; - OpenVarSet openVars; + OpenVarSet openVars, closedVars; // added closedVars AssertionSet needAssertions, haveAssertions; Type *newFirst = first->clone(), *newSecond = second->clone(); env.apply( newFirst ); env.apply( newSecond ); + + // do we need to do this? Seems like we do, types should be able to be compatible if they + // have free variables that can unify + findOpenVars( newFirst, openVars, closedVars, needAssertions, haveAssertions, false ); + findOpenVars( newSecond, openVars, closedVars, needAssertions, haveAssertions, true ); + bool result = unifyExact( newFirst, newSecond, newEnv, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ); delete newFirst; @@ -425,7 +431,31 @@ void Unify::visit(ArrayType *arrayType) { - // XXX -- compare array dimension ArrayType *otherArray = dynamic_cast< ArrayType* >( type2 ); - if ( otherArray && arrayType->get_isVarLen() == otherArray->get_isVarLen() ) { + // to unify, array types must both be VLA or both not VLA + // and must both have a dimension expression or not have a dimension + if ( otherArray && arrayType->get_isVarLen() == otherArray->get_isVarLen() + && ((arrayType->get_dimension() != 0 && otherArray->get_dimension() != 0) + || (arrayType->get_dimension() == 0 && otherArray->get_dimension() == 0))) { + + // not positive this is correct in all cases, but it's needed for typedefs + if ( arrayType->get_isVarLen() || otherArray->get_isVarLen() ) { + return; + } + + if ( ! arrayType->get_isVarLen() && ! otherArray->get_isVarLen() && + arrayType->get_dimension() != 0 && otherArray->get_dimension() != 0 ) { + ConstantExpr * ce1 = dynamic_cast< ConstantExpr * >( arrayType->get_dimension() ); + ConstantExpr * ce2 = dynamic_cast< ConstantExpr * >( otherArray->get_dimension() ); + assert(ce1 && ce2); + + Constant * c1 = ce1->get_constant(); + Constant * c2 = ce2->get_constant(); + + if ( c1->get_value() != c2->get_value() ) { + // does not unify if the dimension is different + return; + } + } + result = unifyExact( arrayType->get_base(), otherArray->get_base(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ); } // if @@ -435,4 +465,6 @@ bool unifyDeclList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, const SymTab::Indexer &indexer ) { for ( ; list1Begin != list1End && list2Begin != list2End; ++list1Begin, ++list2Begin ) { + // Type * commonType; + // if ( ! unifyInexact( (*list1Begin)->get_type(), (*list2Begin)->get_type(), env, needAssertions, haveAssertions, openVars, WidenMode( true, true ), indexer, commonType ) ) { if ( ! unifyExact( (*list1Begin)->get_type(), (*list2Begin)->get_type(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ) ) { return false; @@ -449,5 +481,5 @@ FunctionType *otherFunction = dynamic_cast< FunctionType* >( type2 ); if ( otherFunction && functionType->get_isVarArgs() == otherFunction->get_isVarArgs() ) { - + if ( unifyDeclList( functionType->get_parameters().begin(), functionType->get_parameters().end(), otherFunction->get_parameters().begin(), otherFunction->get_parameters().end(), env, needAssertions, haveAssertions, openVars, indexer ) ) { Index: src/SymTab/IdTable.cc =================================================================== --- src/SymTab/IdTable.cc (revision 258eb5c9477f29166b1ae9152e4dfdd2443eac84) +++ src/SymTab/IdTable.cc (revision 63afee01b295cdf30409284a0c1d8f6f5d5b1049) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Sun May 17 17:04:02 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sun May 17 17:07:43 2015 -// Update Count : 3 +// Last Modified By : Rob Schluntz +// Last Modified On : Wed Oct 07 12:21:13 2015 +// Update Count : 73 // @@ -37,4 +37,5 @@ for ( InnerTableType::iterator inner = outer->second.begin(); inner != outer->second.end(); ++inner ) { std::stack< DeclEntry >& entry = inner->second; + // xxx - should be while? if ( ! entry.empty() && entry.top().second == scopeLevel ) { entry.pop(); @@ -52,4 +53,9 @@ if ( decl->get_linkage() == LinkageSpec::C ) { manglename = name; + } else if ( LinkageSpec::isOverridable( decl->get_linkage() ) ) { + // mangle the name without including the appropriate suffix + // this will make it so that overridable routines are placed + // into the same "bucket" as their user defined versions. + manglename = Mangler::mangle( decl, false ); } else { manglename = Mangler::mangle( decl ); @@ -60,18 +66,36 @@ if ( it == declTable.end() ) { + // first time this name mangling has been defined declTable[ manglename ].push( DeclEntry( decl, scopeLevel ) ); } else { std::stack< DeclEntry >& entry = it->second; if ( ! entry.empty() && entry.top().second == scopeLevel ) { - if ( decl->get_linkage() != LinkageSpec::C || ResolvExpr::typesCompatible( decl->get_type(), entry.top().first->get_type(), Indexer() ) ) { + // if we're giving the same name mangling to things of + // different types then there is something wrong + Declaration *old = entry.top().first; + assert( (dynamic_cast( decl ) && dynamic_cast( old ) ) + || (dynamic_cast( decl ) && dynamic_cast( old ) ) ); + + if ( LinkageSpec::isOverridable( old->get_linkage() ) ) { + // new definition shadows the autogenerated one, even at the same scope + declTable[ manglename ].push( DeclEntry( decl, scopeLevel ) ); + } else if ( decl->get_linkage() != LinkageSpec::C || ResolvExpr::typesCompatible( decl->get_type(), entry.top().first->get_type(), Indexer() ) ) { + // typesCompatible doesn't really do the right thing here. When checking compatibility of function types, + // we should ignore outermost pointer qualifiers, except _Atomic? FunctionDecl *newentry = dynamic_cast< FunctionDecl* >( decl ); - FunctionDecl *old = dynamic_cast< FunctionDecl* >( entry.top().first ); - if ( newentry && old && newentry->get_statements() && old->get_statements() ) { - throw SemanticError( "duplicate function definition for ", decl ); + FunctionDecl *oldentry = dynamic_cast< FunctionDecl* >( old ); + if ( newentry && oldentry ) { + if ( newentry->get_statements() && oldentry->get_statements() ) { + throw SemanticError( "duplicate function definition for 1 ", decl ); + } // if } else { + // two objects with the same mangled name defined in the same scope. + // both objects must be marked extern or both must be intrinsic for this to be okay + // xxx - perhaps it's actually if either is intrinsic then this is okay? + // might also need to be same storage class? ObjectDecl *newobj = dynamic_cast< ObjectDecl* >( decl ); - ObjectDecl *oldobj = dynamic_cast< ObjectDecl* >( entry.top().first ); - if ( newobj && oldobj && newobj->get_init() && oldobj->get_init() ) { - throw SemanticError( "duplicate definition for ", decl ); + ObjectDecl *oldobj = dynamic_cast< ObjectDecl* >( old ); + if (newobj->get_storageClass() != DeclarationNode::Extern && oldobj->get_storageClass() != DeclarationNode::Extern ) { + throw SemanticError( "duplicate definition for 3 ", decl ); } // if } // if @@ -80,8 +104,9 @@ } // if } else { + // new scope level - shadow existing definition declTable[ manglename ].push( DeclEntry( decl, scopeLevel ) ); } // if } // if - // ensure the set of routines with C linkage cannot be overloaded + // this ensures that no two declarations with the same unmangled name both have C linkage for ( InnerTableType::iterator i = declTable.begin(); i != declTable.end(); ++i ) { if ( ! i->second.empty() && i->second.top().first->get_linkage() == LinkageSpec::C && declTable.size() > 1 ) { Index: src/SymTab/Mangler.cc =================================================================== --- src/SymTab/Mangler.cc (revision 258eb5c9477f29166b1ae9152e4dfdd2443eac84) +++ src/SymTab/Mangler.cc (revision 63afee01b295cdf30409284a0c1d8f6f5d5b1049) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Sun May 17 21:40:29 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Mon Jun 8 15:12:12 2015 -// Update Count : 8 +// Last Modified By : Rob Schluntz +// Last Modified On : Wed Aug 19 15:52:24 2015 +// Update Count : 19 // @@ -30,5 +30,5 @@ namespace SymTab { - Mangler::Mangler() : nextVarNum( 0 ), isTopLevel( true ) { + Mangler::Mangler( bool mangleOverridable ) : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ) { } @@ -41,4 +41,5 @@ nextVarNum = rhs.nextVarNum; isTopLevel = rhs.isTopLevel; + mangleOverridable = rhs.mangleOverridable; } @@ -59,4 +60,16 @@ mangleName << "__"; maybeAccept( declaration->get_type(), *this ); + if ( mangleOverridable && LinkageSpec::isOverridable( declaration->get_linkage() ) ) { + // want to be able to override autogenerated and intrinsic routines, + // so they need a different name mangling + if ( declaration->get_linkage() == LinkageSpec::AutoGen ) { + mangleName << "autogen__"; + } else if ( declaration->get_linkage() == LinkageSpec::Intrinsic ) { + mangleName << "intrinsic__"; + } else { + // if we add another kind of overridable function, this has to change + assert( false ); + } // if + } isTopLevel = wasTopLevel; } @@ -214,5 +227,5 @@ varNums[ (*i )->get_name() ] = std::pair< int, int >( nextVarNum++, (int )(*i )->get_kind() ); for ( std::list< DeclarationWithType* >::iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) { - Mangler sub_mangler; + Mangler sub_mangler( mangleOverridable ); sub_mangler.nextVarNum = nextVarNum; sub_mangler.isTopLevel = false; Index: src/SymTab/Mangler.h =================================================================== --- src/SymTab/Mangler.h (revision 258eb5c9477f29166b1ae9152e4dfdd2443eac84) +++ src/SymTab/Mangler.h (revision 63afee01b295cdf30409284a0c1d8f6f5d5b1049) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Sun May 17 21:44:03 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Mon Jun 8 14:47:14 2015 -// Update Count : 5 +// Last Modified By : Rob Schluntz +// Last Modified On : Wed Aug 19 15:48:46 2015 +// Update Count : 14 // @@ -25,5 +25,5 @@ public: template< typename SynTreeClass > - static std::string mangle( SynTreeClass *decl ); // interface to clients + static std::string mangle( SynTreeClass *decl, bool mangleOverridable = true ); // interface to clients /// using Visitor::visit; @@ -50,6 +50,7 @@ int nextVarNum; bool isTopLevel; + bool mangleOverridable; - Mangler(); + Mangler( bool mangleOverridable ); Mangler( const Mangler & ); @@ -61,6 +62,6 @@ template< typename SynTreeClass > - std::string Mangler::mangle( SynTreeClass *decl ) { - Mangler mangler; + std::string Mangler::mangle( SynTreeClass *decl, bool mangleOverridable ) { + Mangler mangler( mangleOverridable ); maybeAccept( decl, mangler ); return mangler.get_mangleName(); Index: src/SymTab/Validate.cc =================================================================== --- src/SymTab/Validate.cc (revision 258eb5c9477f29166b1ae9152e4dfdd2443eac84) +++ src/SymTab/Validate.cc (revision 63afee01b295cdf30409284a0c1d8f6f5d5b1049) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Sun May 17 21:50:04 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Tue Aug 11 16:59:35 2015 -// Update Count : 196 +// Last Modified By : Rob Schluntz +// Last Modified On : Thu Nov 19 10:44:55 2015 +// Update Count : 199 // @@ -54,4 +54,5 @@ #include "MakeLibCfa.h" #include "TypeEquality.h" +#include "ResolvExpr/typeops.h" #define debugPrint( x ) if ( doDebug ) { std::cout << x; } @@ -125,8 +126,8 @@ }; - class AddStructAssignment : public Visitor { + class AutogenerateRoutines : public Visitor { public: /// Generates assignment operators for aggregate types as required - static void addStructAssignment( std::list< Declaration * > &translationUnit ); + static void autogenerateRoutines( std::list< Declaration * > &translationUnit ); std::list< Declaration * > &get_declsToAdd() { return declsToAdd; } @@ -151,5 +152,5 @@ virtual void visit( CatchStmt *catchStmt ); - AddStructAssignment() : functionNesting( 0 ) {} + AutogenerateRoutines() : functionNesting( 0 ) {} private: template< typename StmtClass > void visitStatement( StmtClass *stmt ); @@ -195,7 +196,5 @@ acceptAll( translationUnit, pass1 ); acceptAll( translationUnit, pass2 ); - // need to collect all of the assignment operators prior to - // this point and only generate assignment operators if one doesn't exist - AddStructAssignment::addStructAssignment( translationUnit ); + AutogenerateRoutines::autogenerateRoutines( translationUnit ); acceptAll( translationUnit, pass3 ); } @@ -501,6 +500,6 @@ static const std::list< std::string > noLabels; - void AddStructAssignment::addStructAssignment( std::list< Declaration * > &translationUnit ) { - AddStructAssignment visitor; + void AutogenerateRoutines::autogenerateRoutines( std::list< Declaration * > &translationUnit ) { + AutogenerateRoutines visitor; acceptAndAdd( translationUnit, visitor, false ); } @@ -704,5 +703,5 @@ } - void AddStructAssignment::visit( EnumDecl *enumDecl ) { + void AutogenerateRoutines::visit( EnumDecl *enumDecl ) { if ( ! enumDecl->get_members().empty() ) { EnumInstType *enumInst = new EnumInstType( Type::Qualifiers(), enumDecl->get_name() ); @@ -713,5 +712,5 @@ } - void AddStructAssignment::visit( StructDecl *structDecl ) { + void AutogenerateRoutines::visit( StructDecl *structDecl ) { if ( ! structDecl->get_members().empty() && structsDone.find( structDecl->get_name() ) == structsDone.end() ) { StructInstType *structInst = new StructInstType( Type::Qualifiers(), structDecl->get_name() ); @@ -722,5 +721,5 @@ } - void AddStructAssignment::visit( UnionDecl *unionDecl ) { + void AutogenerateRoutines::visit( UnionDecl *unionDecl ) { if ( ! unionDecl->get_members().empty() ) { UnionInstType *unionInst = new UnionInstType( Type::Qualifiers(), unionDecl->get_name() ); @@ -730,5 +729,5 @@ } - void AddStructAssignment::visit( TypeDecl *typeDecl ) { + void AutogenerateRoutines::visit( TypeDecl *typeDecl ) { CompoundStmt *stmts = 0; TypeInstType *typeInst = new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), false ); @@ -758,18 +757,18 @@ } - void AddStructAssignment::visit( FunctionType *) { + void AutogenerateRoutines::visit( FunctionType *) { // ensure that we don't add assignment ops for types defined as part of the function } - void AddStructAssignment::visit( PointerType *) { + void AutogenerateRoutines::visit( PointerType *) { // ensure that we don't add assignment ops for types defined as part of the pointer } - void AddStructAssignment::visit( ContextDecl *) { + void AutogenerateRoutines::visit( ContextDecl *) { // ensure that we don't add assignment ops for types defined as part of the context } template< typename StmtClass > - inline void AddStructAssignment::visitStatement( StmtClass *stmt ) { + inline void AutogenerateRoutines::visitStatement( StmtClass *stmt ) { std::set< std::string > oldStructs = structsDone; addVisit( stmt, *this ); @@ -777,5 +776,5 @@ } - void AddStructAssignment::visit( FunctionDecl *functionDecl ) { + void AutogenerateRoutines::visit( FunctionDecl *functionDecl ) { maybeAccept( functionDecl->get_functionType(), *this ); acceptAll( functionDecl->get_oldDecls(), *this ); @@ -785,33 +784,33 @@ } - void AddStructAssignment::visit( CompoundStmt *compoundStmt ) { + void AutogenerateRoutines::visit( CompoundStmt *compoundStmt ) { visitStatement( compoundStmt ); } - void AddStructAssignment::visit( IfStmt *ifStmt ) { + void AutogenerateRoutines::visit( IfStmt *ifStmt ) { visitStatement( ifStmt ); } - void AddStructAssignment::visit( WhileStmt *whileStmt ) { + void AutogenerateRoutines::visit( WhileStmt *whileStmt ) { visitStatement( whileStmt ); } - void AddStructAssignment::visit( ForStmt *forStmt ) { + void AutogenerateRoutines::visit( ForStmt *forStmt ) { visitStatement( forStmt ); } - void AddStructAssignment::visit( SwitchStmt *switchStmt ) { + void AutogenerateRoutines::visit( SwitchStmt *switchStmt ) { visitStatement( switchStmt ); } - void AddStructAssignment::visit( ChooseStmt *switchStmt ) { + void AutogenerateRoutines::visit( ChooseStmt *switchStmt ) { visitStatement( switchStmt ); } - void AddStructAssignment::visit( CaseStmt *caseStmt ) { + void AutogenerateRoutines::visit( CaseStmt *caseStmt ) { visitStatement( caseStmt ); } - void AddStructAssignment::visit( CatchStmt *cathStmt ) { + void AutogenerateRoutines::visit( CatchStmt *cathStmt ) { visitStatement( cathStmt ); } @@ -857,5 +856,5 @@ Type * t1 = tyDecl->get_base(); Type * t2 = typedefNames[ tyDecl->get_name() ].first->get_base(); - if ( ! typeEquals( t1, t2, true ) ) { + if ( ! ResolvExpr::typesCompatible( t1, t2, Indexer() ) ) { throw SemanticError( "cannot redefine typedef: " + tyDecl->get_name() ); } Index: src/SynTree/ObjectDecl.cc =================================================================== --- src/SynTree/ObjectDecl.cc (revision 258eb5c9477f29166b1ae9152e4dfdd2443eac84) +++ src/SynTree/ObjectDecl.cc (revision 63afee01b295cdf30409284a0c1d8f6f5d5b1049) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Mon Jul 13 18:08:27 2015 -// Update Count : 16 +// Last Modified By : Rob Schluntz +// Last Modified On : Tue Sep 29 14:13:01 2015 +// Update Count : 18 // @@ -52,14 +52,14 @@ get_type()->print( os, indent ); } else { - os << "untyped entity "; + os << " untyped entity "; } // if if ( init ) { - os << "with initializer "; + os << " with initializer "; init->print( os, indent ); } // if if ( bitfieldWidth ) { - os << "with bitfield width "; + os << " with bitfield width "; bitfieldWidth->print( os ); } // if Index: src/libcfa/prelude.cf =================================================================== --- src/libcfa/prelude.cf (revision 258eb5c9477f29166b1ae9152e4dfdd2443eac84) +++ src/libcfa/prelude.cf (revision 63afee01b295cdf30409284a0c1d8f6f5d5b1049) @@ -7,7 +7,7 @@ // Author : Glen Ditchfield // Created On : Sat Nov 29 07:23:41 2014 -// Last Modified By : Peter A. Buhr -// Last Modified On : Tue Jun 9 14:43:47 2015 -// Update Count : 75 +// Last Modified By : Rob Schluntz +// Last Modified On : Thu Nov 19 11:09:47 2015 +// Update Count : 76 //