Index: src/ResolvExpr/AdjustExprType.cc =================================================================== --- src/ResolvExpr/AdjustExprType.cc (revision 7870799883ca946218c97fb6a189d1da90a16e8e) +++ src/ResolvExpr/AdjustExprType.cc (revision ef5b8288bd2be4816de42f8ea6a9b3d5e5971b31) @@ -47,7 +47,7 @@ void premutate( OneType * ) { visit_children = false; } - Type * postmutate( ArrayType *arrayType ); - Type * postmutate( FunctionType *functionType ); - Type * postmutate( TypeInstType *aggregateUseType ); + Type * postmutate( ArrayType * arrayType ); + Type * postmutate( FunctionType * functionType ); + Type * postmutate( TypeInstType * aggregateUseType ); private: @@ -61,5 +61,5 @@ Type * AdjustExprType_old::postmutate( ArrayType * arrayType ) { - PointerType *pointerType = new PointerType{ arrayType->get_qualifiers(), arrayType->base }; + PointerType * pointerType = new PointerType{ arrayType->get_qualifiers(), arrayType->base }; arrayType->base = nullptr; delete arrayType; @@ -72,10 +72,10 @@ Type * AdjustExprType_old::postmutate( TypeInstType * typeInst ) { - if ( const EqvClass* eqvClass = env.lookup( typeInst->get_name() ) ) { + if ( const EqvClass * eqvClass = env.lookup( typeInst->get_name() ) ) { if ( eqvClass->data.kind == TypeDecl::Ftype ) { return new PointerType{ Type::Qualifiers(), typeInst }; } - } else if ( NamedTypeDecl *ntDecl = indexer.lookupType( typeInst->get_name() ) ) { - if ( TypeDecl *tyDecl = dynamic_cast< TypeDecl* >( ntDecl ) ) { + } else if ( const NamedTypeDecl * ntDecl = indexer.lookupType( typeInst->get_name() ) ) { + if ( const TypeDecl * tyDecl = dynamic_cast< const TypeDecl * >( ntDecl ) ) { if ( tyDecl->get_kind() == TypeDecl::Ftype ) { return new PointerType{ Type::Qualifiers(), typeInst }; @@ -89,5 +89,5 @@ void adjustExprType( Type *&type, const TypeEnvironment &env, const SymTab::Indexer &indexer ) { PassVisitor adjuster( env, indexer ); - Type *newType = type->acceptMutator( adjuster ); + Type * newType = type->acceptMutator( adjuster ); type = newType; } @@ -148,6 +148,6 @@ } // anonymous namespace -const ast::Type * adjustExprType( - const ast::Type * type, const ast::TypeEnvironment & env, const ast::SymbolTable & symtab +const ast::Type * adjustExprType( + const ast::Type * type, const ast::TypeEnvironment & env, const ast::SymbolTable & symtab ) { ast::Pass adjuster{ env, symtab }; Index: src/ResolvExpr/CastCost.cc =================================================================== --- src/ResolvExpr/CastCost.cc (revision 7870799883ca946218c97fb6a189d1da90a16e8e) +++ src/ResolvExpr/CastCost.cc (revision ef5b8288bd2be4816de42f8ea6a9b3d5e5971b31) @@ -37,5 +37,5 @@ struct CastCost_old : public ConversionCost { public: - CastCost_old( const Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc ); + CastCost_old( const Type * dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc ); using ConversionCost::previsit; @@ -45,7 +45,7 @@ }; - Cost castCost( const Type *src, const Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) { - if ( const TypeInstType *destAsTypeInst = dynamic_cast< const TypeInstType* >( dest ) ) { - if ( const EqvClass* eqvClass = env.lookup( destAsTypeInst->name ) ) { + Cost castCost( const Type * src, const Type * dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) { + if ( const TypeInstType * destAsTypeInst = dynamic_cast< const TypeInstType * >( dest ) ) { + if ( const EqvClass * eqvClass = env.lookup( destAsTypeInst->name ) ) { if ( eqvClass->type ) { return castCost( src, eqvClass->type, indexer, env ); @@ -53,7 +53,7 @@ return Cost::infinity; } - } else if ( NamedTypeDecl *namedType = indexer.lookupType( destAsTypeInst->name ) ) { + } else if ( const NamedTypeDecl * namedType = indexer.lookupType( destAsTypeInst->name ) ) { // all typedefs should be gone by this point - const TypeDecl * type = strict_dynamic_cast< const TypeDecl* >( namedType ); + const TypeDecl * type = strict_dynamic_cast< const TypeDecl * >( namedType ); if ( type->base ) { return castCost( src, type->base, indexer, env ) + Cost::safe; @@ -74,5 +74,5 @@ PRINT( std::cerr << "compatible!" << std::endl; ) return Cost::zero; - } else if ( dynamic_cast< const VoidType* >( dest ) ) { + } else if ( dynamic_cast< const VoidType * >( dest ) ) { return Cost::safe; } else if ( const ReferenceType * refType = dynamic_cast< const ReferenceType * > ( dest ) ) { @@ -96,12 +96,12 @@ } - CastCost_old::CastCost_old( const Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc ) + CastCost_old::CastCost_old( const Type * dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc ) : ConversionCost( dest, indexer, env, costFunc ) { } - void CastCost_old::postvisit( const BasicType *basicType ) { - const PointerType *destAsPointer = dynamic_cast< const PointerType* >( dest ); + void CastCost_old::postvisit( const BasicType * basicType ) { + const PointerType * destAsPointer = dynamic_cast< const PointerType * >( dest ); if ( destAsPointer && basicType->isInteger() ) { - // necessary for, e.g. unsigned long => void* + // necessary for, e.g. unsigned long => void * cost = Cost::unsafe; } else { @@ -110,6 +110,6 @@ } - void CastCost_old::postvisit( const PointerType *pointerType ) { - if ( const PointerType *destAsPtr = dynamic_cast< const PointerType* >( dest ) ) { + void CastCost_old::postvisit( const PointerType * pointerType ) { + if ( const PointerType * destAsPtr = dynamic_cast< const PointerType * >( dest ) ) { if ( pointerType->tq <= destAsPtr->tq && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) { cost = Cost::safe; @@ -127,5 +127,5 @@ } else if ( const BasicType * destAsBasic = dynamic_cast< const BasicType * >( dest ) ) { if ( destAsBasic->isInteger() ) { - // necessary for, e.g. void* => unsigned long + // necessary for, e.g. void * => unsigned long cost = Cost::unsafe; } // if Index: src/ResolvExpr/CommonType.cc =================================================================== --- src/ResolvExpr/CommonType.cc (revision 7870799883ca946218c97fb6a189d1da90a16e8e) +++ src/ResolvExpr/CommonType.cc (revision ef5b8288bd2be4816de42f8ea6a9b3d5e5971b31) @@ -38,6 +38,6 @@ namespace ResolvExpr { struct CommonType_old : public WithShortCircuiting { - CommonType_old( Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars ); - Type *get_result() const { return result; } + CommonType_old( Type * type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars ); + Type * get_result() const { return result; } void previsit( BaseSyntaxNode * ) { visit_children = false; } @@ -60,9 +60,9 @@ private: - template< typename Pointer > void getCommonWithVoidPointer( Pointer* voidPointer, Pointer* otherPointer ); - template< typename RefType > void handleRefType( RefType *inst, Type *other ); - - Type *result; - Type *type2; // inherited + template< typename Pointer > void getCommonWithVoidPointer( Pointer * voidPointer, Pointer * otherPointer ); + template< typename RefType > void handleRefType( RefType * inst, Type * other ); + + Type * result; + Type * type2; // inherited bool widenFirst, widenSecond; const SymTab::Indexer &indexer; @@ -80,10 +80,10 @@ std::cerr << "unify success: " << widenFirst << " " << widenSecond << std::endl; ) - if ( (widenFirst || t2->get_qualifiers() <= t1->get_qualifiers()) && (widenSecond || t1->get_qualifiers() <= t2->get_qualifiers()) ) { + if ( (widenFirst || t2->tq <= t1->tq) && (widenSecond || t1->tq <= t2->tq) ) { PRINT( std::cerr << "widen okay" << std::endl; ) - common->get_qualifiers() |= t1->get_qualifiers(); - common->get_qualifiers() |= t2->get_qualifiers(); + common->tq |= t1->tq; + common->tq |= t2->tq; return common; } @@ -95,5 +95,5 @@ } - Type *commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars ) { + Type * commonType( Type * type1, Type * type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars ) { PassVisitor visitor( type2, widenFirst, widenSecond, indexer, env, openVars ); @@ -127,5 +127,5 @@ std::cerr << "formal is reference; result should be reference" << std::endl; ) - result = new ReferenceType( ref1->get_qualifiers(), result ); + result = new ReferenceType( ref1->tq, result ); } PRINT( @@ -138,23 +138,23 @@ type1->accept( visitor ); - Type *result = visitor.pass.get_result(); + Type * result = visitor.pass.get_result(); if ( ! result ) { // this appears to be handling for opaque type declarations if ( widenSecond ) { - if ( TypeInstType *inst = dynamic_cast< TypeInstType* >( type2 ) ) { - if ( NamedTypeDecl *nt = indexer.lookupType( inst->get_name() ) ) { - TypeDecl *type = strict_dynamic_cast< TypeDecl* >( nt ); + if ( const TypeInstType * inst = dynamic_cast< const TypeInstType * >( type2 ) ) { + if ( const NamedTypeDecl * nt = indexer.lookupType( inst->get_name() ) ) { + const TypeDecl * type = strict_dynamic_cast< const TypeDecl * >( nt ); if ( type->get_base() ) { - Type::Qualifiers tq1 = type1->get_qualifiers(), tq2 = type2->get_qualifiers(); + Type::Qualifiers tq1 = type1->tq, tq2 = type2->tq; AssertionSet have, need; OpenVarSet newOpen( openVars ); - type1->get_qualifiers() = Type::Qualifiers(); - type->get_base()->get_qualifiers() = tq1; + type1->tq = Type::Qualifiers(); + type->get_base()->tq = tq1; if ( unifyExact( type1, type->get_base(), env, have, need, newOpen, indexer ) ) { result = type1->clone(); - result->get_qualifiers() = tq1 | tq2; + result->tq = tq1 | tq2; } // if - type1->get_qualifiers() = tq1; - type->get_base()->get_qualifiers() = Type::Qualifiers(); + type1->tq = tq1; + type->get_base()->tq = Type::Qualifiers(); } // if } // if @@ -190,5 +190,5 @@ */ { - /* B*/ BT Bool, BT Char, BT SignedChar, BT UnsignedChar, BT ShortSignedInt, BT ShortUnsignedInt, + /* B */ BT Bool, BT Char, BT SignedChar, BT UnsignedChar, BT ShortSignedInt, BT ShortUnsignedInt, BT SignedInt, BT UnsignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, @@ -198,5 +198,5 @@ }, { - /* C*/ BT Char, BT Char, BT SignedChar, BT UnsignedChar, BT ShortSignedInt, BT ShortUnsignedInt, + /* C */ BT Char, BT Char, BT SignedChar, BT UnsignedChar, BT ShortSignedInt, BT ShortUnsignedInt, BT SignedInt, BT UnsignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, @@ -206,5 +206,5 @@ }, { - /* SC*/ BT SignedChar, BT SignedChar, BT SignedChar, BT UnsignedChar, BT ShortSignedInt, BT ShortUnsignedInt, + /* SC */ BT SignedChar, BT SignedChar, BT SignedChar, BT UnsignedChar, BT ShortSignedInt, BT ShortUnsignedInt, BT SignedInt, BT UnsignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, @@ -214,5 +214,5 @@ }, { - /* UC*/ BT UnsignedChar, BT UnsignedChar, BT UnsignedChar, BT UnsignedChar, BT ShortSignedInt, BT ShortUnsignedInt, + /* UC */ BT UnsignedChar, BT UnsignedChar, BT UnsignedChar, BT UnsignedChar, BT ShortSignedInt, BT ShortUnsignedInt, BT SignedInt, BT UnsignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, @@ -222,5 +222,5 @@ }, { - /* SI*/ BT ShortSignedInt, BT ShortSignedInt, BT ShortSignedInt, BT ShortSignedInt, BT ShortSignedInt, BT ShortUnsignedInt, + /* SI */ BT ShortSignedInt, BT ShortSignedInt, BT ShortSignedInt, BT ShortSignedInt, BT ShortSignedInt, BT ShortUnsignedInt, BT SignedInt, BT UnsignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, @@ -230,5 +230,5 @@ }, { - /* SUI*/ BT ShortUnsignedInt, BT ShortUnsignedInt, BT ShortUnsignedInt, BT ShortUnsignedInt, BT ShortUnsignedInt, BT ShortUnsignedInt, + /* SUI */ BT ShortUnsignedInt, BT ShortUnsignedInt, BT ShortUnsignedInt, BT ShortUnsignedInt, BT ShortUnsignedInt, BT ShortUnsignedInt, BT SignedInt, BT UnsignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, @@ -238,5 +238,5 @@ }, { - /* I*/ BT SignedInt, BT SignedInt, BT SignedInt, BT SignedInt, BT SignedInt, BT SignedInt, + /* I */ BT SignedInt, BT SignedInt, BT SignedInt, BT SignedInt, BT SignedInt, BT SignedInt, BT SignedInt, BT UnsignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, @@ -246,5 +246,5 @@ }, { - /* UI*/ BT UnsignedInt, BT UnsignedInt, BT UnsignedInt, BT UnsignedInt, BT UnsignedInt, BT UnsignedInt, + /* UI */ BT UnsignedInt, BT UnsignedInt, BT UnsignedInt, BT UnsignedInt, BT UnsignedInt, BT UnsignedInt, BT UnsignedInt, BT UnsignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, @@ -254,5 +254,5 @@ }, { - /* LI*/ BT LongSignedInt, BT LongSignedInt, BT LongSignedInt, BT LongSignedInt, BT LongSignedInt, BT LongSignedInt, + /* LI */ BT LongSignedInt, BT LongSignedInt, BT LongSignedInt, BT LongSignedInt, BT LongSignedInt, BT LongSignedInt, BT LongSignedInt, BT LongSignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, @@ -262,5 +262,5 @@ }, { - /* LUI*/ BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, + /* LUI */ BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, @@ -270,5 +270,5 @@ }, { - /* LLI*/ BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, + /* LLI */ BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, @@ -278,5 +278,5 @@ }, { - /* LLUI*/ BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, + /* LLUI */ BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, @@ -286,5 +286,5 @@ }, { - /* IB*/ BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, + /* IB */ BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, @@ -294,5 +294,5 @@ }, { - /* UIB*/ BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, + /* UIB */ BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, @@ -302,5 +302,5 @@ }, { - /* _FH*/ BT uFloat16, BT uFloat16, BT uFloat16, BT uFloat16, BT uFloat16, BT uFloat16, + /* _FH */ BT uFloat16, BT uFloat16, BT uFloat16, BT uFloat16, BT uFloat16, BT uFloat16, BT uFloat16, BT uFloat16, BT uFloat16, BT uFloat16, BT uFloat16, BT uFloat16, BT uFloat16, BT uFloat16, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, @@ -310,5 +310,5 @@ }, { - /* _FH*/ BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, + /* _FH */ BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, BT uFloat32Complex, BT uFloat32Complex, @@ -318,5 +318,5 @@ }, { - /* _F*/ BT uFloat32, BT uFloat32, BT uFloat32, BT uFloat32, BT uFloat32, BT uFloat32, + /* _F */ BT uFloat32, BT uFloat32, BT uFloat32, BT uFloat32, BT uFloat32, BT uFloat32, BT uFloat32, BT uFloat32, BT uFloat32, BT uFloat32, BT uFloat32, BT uFloat32, BT uFloat32, BT uFloat32, BT uFloat32, BT uFloat32Complex, BT uFloat32, BT uFloat32Complex, @@ -326,5 +326,5 @@ }, { - /* _FC*/ BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, + /* _FC */ BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, @@ -334,5 +334,5 @@ }, { - /* F*/ BT Float, BT Float, BT Float, BT Float, BT Float, BT Float, + /* F */ BT Float, BT Float, BT Float, BT Float, BT Float, BT Float, BT Float, BT Float, BT Float, BT Float, BT Float, BT Float, BT Float, BT Float, BT Float, BT FloatComplex, BT Float, BT FloatComplex, @@ -342,5 +342,5 @@ }, { - /* FC*/ BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, + /* FC */ BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, @@ -350,5 +350,5 @@ }, { - /* _FX*/ BT uFloat32x, BT uFloat32x, BT uFloat32x, BT uFloat32x, BT uFloat32x, BT uFloat32x, + /* _FX */ BT uFloat32x, BT uFloat32x, BT uFloat32x, BT uFloat32x, BT uFloat32x, BT uFloat32x, BT uFloat32x, BT uFloat32x, BT uFloat32x, BT uFloat32x, BT uFloat32x, BT uFloat32x, BT uFloat32x, BT uFloat32x, BT uFloat32x, BT uFloat32xComplex, BT uFloat32x, BT uFloat32xComplex, @@ -358,5 +358,5 @@ }, { - /* _FXC*/ BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, + /* _FXC */ BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, @@ -366,5 +366,5 @@ }, { - /* FD*/ BT uFloat64, BT uFloat64, BT uFloat64, BT uFloat64, BT uFloat64, BT uFloat64, + /* FD */ BT uFloat64, BT uFloat64, BT uFloat64, BT uFloat64, BT uFloat64, BT uFloat64, BT uFloat64, BT uFloat64, BT uFloat64, BT uFloat64, BT uFloat64, BT uFloat64, BT uFloat64, BT uFloat64, BT uFloat64, BT uFloat64Complex, BT uFloat64, BT uFloat64Complex, @@ -374,5 +374,5 @@ }, { - /* _FDC*/ BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, + /* _FDC */ BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, @@ -382,5 +382,5 @@ }, { - /* D*/ BT Double, BT Double, BT Double, BT Double, BT Double, BT Double, + /* D */ BT Double, BT Double, BT Double, BT Double, BT Double, BT Double, BT Double, BT Double, BT Double, BT Double, BT Double, BT Double, BT Double, BT Double, BT Double, BT DoubleComplex, BT Double, BT DoubleComplex, @@ -390,5 +390,5 @@ }, { - /* DC*/ BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, + /* DC */ BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, @@ -398,5 +398,5 @@ }, { - /* F80X*/ BT uFloat64x, BT uFloat64x, BT uFloat64x, BT uFloat64x, BT uFloat64x, BT uFloat64x, + /* F80X */ BT uFloat64x, BT uFloat64x, BT uFloat64x, BT uFloat64x, BT uFloat64x, BT uFloat64x, BT uFloat64x, BT uFloat64x, BT uFloat64x, BT uFloat64x, BT uFloat64x, BT uFloat64x, BT uFloat64x, BT uFloat64x, BT uFloat64x, BT uFloat64xComplex, BT uFloat64x, BT uFloat64xComplex, @@ -406,5 +406,5 @@ }, { - /* _FDXC*/ BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, + /* _FDXC */ BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, @@ -422,5 +422,5 @@ }, { - /* _FB*/ BT uFloat128, BT uFloat128, BT uFloat128, BT uFloat128, BT uFloat128, BT uFloat128, + /* _FB */ BT uFloat128, BT uFloat128, BT uFloat128, BT uFloat128, BT uFloat128, BT uFloat128, BT uFloat128, BT uFloat128, BT uFloat128, BT uFloat128, BT uFloat128, BT uFloat128, BT uFloat128, BT uFloat128, BT uFloat128, BT uFloat128Complex, BT uFloat128, BT uFloat128Complex, @@ -430,5 +430,5 @@ }, { - /* _FLDC*/ BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, + /* _FLDC */ BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, @@ -438,5 +438,5 @@ }, { - /* FB*/ BT uuFloat128, BT uuFloat128, BT uuFloat128, BT uuFloat128, BT uuFloat128, BT uuFloat128, + /* FB */ BT uuFloat128, BT uuFloat128, BT uuFloat128, BT uuFloat128, BT uuFloat128, BT uuFloat128, BT uuFloat128, BT uuFloat128, BT uuFloat128, BT uuFloat128, BT uuFloat128, BT uuFloat128, BT uuFloat128, BT uuFloat128, BT uuFloat128, BT uFloat128Complex, BT uuFloat128, BT uFloat128Complex, @@ -446,5 +446,5 @@ }, { - /* LD*/ BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, + /* LD */ BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDoubleComplex, BT LongDouble, BT LongDoubleComplex, @@ -454,5 +454,5 @@ }, { - /* LDC*/ BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, + /* LDC */ BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, @@ -462,5 +462,5 @@ }, { - /* _FBX*/ BT uFloat128x, BT uFloat128x, BT uFloat128x, BT uFloat128x, BT uFloat128x, BT uFloat128x, + /* _FBX */ BT uFloat128x, BT uFloat128x, BT uFloat128x, BT uFloat128x, BT uFloat128x, BT uFloat128x, BT uFloat128x, BT uFloat128x, BT uFloat128x, BT uFloat128x, BT uFloat128x, BT uFloat128x, BT uFloat128x, BT uFloat128x, BT uFloat128x, BT uFloat128xComplex, BT uFloat128x, BT uFloat128xComplex, @@ -470,5 +470,5 @@ }, { - /*_FLDXC*/ BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, + /* _FLDXC */ BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, @@ -481,9 +481,9 @@ // GENERATED END static_assert( - sizeof(commonTypes)/sizeof(commonTypes[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES, + sizeof(commonTypes)/sizeof(commonTypes[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES * BasicType::NUMBER_OF_BASIC_TYPES, "Each basic type kind should have a corresponding row in the combined type matrix" ); - CommonType_old::CommonType_old( Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars ) + CommonType_old::CommonType_old( Type * type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars ) : result( 0 ), type2( type2 ), widenFirst( widenFirst ), widenSecond( widenSecond ), indexer( indexer ), env( env ), openVars( openVars ) { } @@ -491,15 +491,15 @@ void CommonType_old::postvisit( VoidType * ) {} - void CommonType_old::postvisit( BasicType *basicType ) { - if ( BasicType *otherBasic = dynamic_cast< BasicType* >( type2 ) ) { + void CommonType_old::postvisit( BasicType * basicType ) { + if ( BasicType * otherBasic = dynamic_cast< BasicType * >( type2 ) ) { BasicType::Kind newType = commonTypes[ basicType->get_kind() ][ otherBasic->get_kind() ]; - if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= otherBasic->get_qualifiers() ) || widenFirst ) && ( ( newType == otherBasic->get_kind() && basicType->get_qualifiers() <= otherBasic->get_qualifiers() ) || widenSecond ) ) { - result = new BasicType( basicType->get_qualifiers() | otherBasic->get_qualifiers(), newType ); + if ( ( ( newType == basicType->get_kind() && basicType->tq >= otherBasic->tq ) || widenFirst ) && ( ( newType == otherBasic->get_kind() && basicType->tq <= otherBasic->tq ) || widenSecond ) ) { + result = new BasicType( basicType->tq | otherBasic->tq, newType ); } // if - } else if ( dynamic_cast< EnumInstType * > ( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) { + } else if ( dynamic_cast< EnumInstType * > ( type2 ) || dynamic_cast< ZeroType * >( type2 ) || dynamic_cast< OneType * >( type2 ) ) { // use signed int in lieu of the enum/zero/one type BasicType::Kind newType = commonTypes[ basicType->get_kind() ][ BasicType::SignedInt ]; - if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= type2->get_qualifiers() ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->get_qualifiers() <= type2->get_qualifiers() ) || widenSecond ) ) { - result = new BasicType( basicType->get_qualifiers() | type2->get_qualifiers(), newType ); + if ( ( ( newType == basicType->get_kind() && basicType->tq >= type2->tq ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->tq <= type2->tq ) || widenSecond ) ) { + result = new BasicType( basicType->tq | type2->tq, newType ); } // if } // if @@ -507,6 +507,6 @@ template< typename Pointer > - void CommonType_old::getCommonWithVoidPointer( Pointer* voidPointer, Pointer* otherPointer ) { - if ( TypeInstType* var = dynamic_cast< TypeInstType* >( otherPointer->get_base() ) ) { + void CommonType_old::getCommonWithVoidPointer( Pointer * voidPointer, Pointer * otherPointer ) { + if ( TypeInstType * var = dynamic_cast< TypeInstType * >( otherPointer->get_base() ) ) { OpenVarSet::const_iterator entry = openVars.find( var->get_name() ); if ( entry != openVars.end() ) { @@ -517,20 +517,20 @@ } result = voidPointer->clone(); - result->get_qualifiers() |= otherPointer->get_qualifiers(); - } - - void CommonType_old::postvisit( PointerType *pointerType ) { - if ( PointerType *otherPointer = dynamic_cast< PointerType* >( type2 ) ) { + result->tq |= otherPointer->tq; + } + + void CommonType_old::postvisit( PointerType * pointerType ) { + if ( PointerType * otherPointer = dynamic_cast< PointerType * >( type2 ) ) { // std::cerr << "commonType: two pointers: " << pointerType << " / " << otherPointer << std::endl; - if ( widenFirst && dynamic_cast< VoidType* >( otherPointer->get_base() ) && ! isFtype(pointerType->get_base()) ) { + if ( widenFirst && dynamic_cast< VoidType * >( otherPointer->get_base() ) && ! isFtype(pointerType->get_base()) ) { getCommonWithVoidPointer( otherPointer, pointerType ); - } else if ( widenSecond && dynamic_cast< VoidType* >( pointerType->get_base() ) && ! isFtype(otherPointer->get_base()) ) { + } else if ( widenSecond && dynamic_cast< VoidType * >( pointerType->get_base() ) && ! isFtype(otherPointer->get_base()) ) { getCommonWithVoidPointer( pointerType, otherPointer ); - } else if ( ( pointerType->get_base()->get_qualifiers() >= otherPointer->get_base()->get_qualifiers() || widenFirst ) - && ( pointerType->get_base()->get_qualifiers() <= otherPointer->get_base()->get_qualifiers() || widenSecond ) ) { + } else if ( ( pointerType->get_base()->tq >= otherPointer->get_base()->tq || widenFirst ) + && ( pointerType->get_base()->tq <= otherPointer->get_base()->tq || widenSecond ) ) { // std::cerr << "middle case" << std::endl; - Type::Qualifiers tq1 = pointerType->get_base()->get_qualifiers(), tq2 = otherPointer->get_base()->get_qualifiers(); - pointerType->get_base()->get_qualifiers() = Type::Qualifiers(); - otherPointer->get_base()->get_qualifiers() = Type::Qualifiers(); + Type::Qualifiers tq1 = pointerType->get_base()->tq, tq2 = otherPointer->get_base()->tq; + pointerType->get_base()->tq = Type::Qualifiers(); + otherPointer->get_base()->tq = Type::Qualifiers(); AssertionSet have, need; OpenVarSet newOpen( openVars ); @@ -542,14 +542,14 @@ result = otherPointer->clone(); } // if - strict_dynamic_cast(result)->base->get_qualifiers() = tq1 | tq2; + strict_dynamic_cast(result)->base->tq = tq1 | tq2; } else { /// std::cerr << "place for ptr-to-type" << std::endl; } // if - pointerType->get_base()->get_qualifiers() = tq1; - otherPointer->get_base()->get_qualifiers() = tq2; + pointerType->get_base()->tq = tq1; + otherPointer->get_base()->tq = tq2; } // if - } else if ( widenSecond && dynamic_cast< ZeroType* >( type2 ) ) { + } else if ( widenSecond && dynamic_cast< ZeroType * >( type2 ) ) { result = pointerType->clone(); - result->get_qualifiers() |= type2->get_qualifiers(); + result->tq |= type2->tq; } // if } @@ -557,18 +557,18 @@ void CommonType_old::postvisit( ArrayType * ) {} - void CommonType_old::postvisit( ReferenceType *refType ) { - if ( ReferenceType *otherRef = dynamic_cast< ReferenceType* >( type2 ) ) { + void CommonType_old::postvisit( ReferenceType * refType ) { + if ( ReferenceType * otherRef = dynamic_cast< ReferenceType * >( type2 ) ) { // std::cerr << "commonType: both references: " << refType << " / " << otherRef << std::endl; - // std::cerr << ( refType->get_base()->get_qualifiers() >= otherRef->get_base()->get_qualifiers() || widenFirst ) << (refType->get_base()->get_qualifiers() <= otherRef->get_base()->get_qualifiers() || widenSecond) << std::endl; - if ( widenFirst && dynamic_cast< VoidType* >( otherRef->get_base() ) && ! isFtype(refType->get_base()) ) { + // std::cerr << ( refType->get_base()->tq >= otherRef->get_base()->tq || widenFirst ) << (refType->get_base()->tq <= otherRef->get_base()->tq || widenSecond) << std::endl; + if ( widenFirst && dynamic_cast< VoidType * >( otherRef->get_base() ) && ! isFtype(refType->get_base()) ) { getCommonWithVoidPointer( otherRef, refType ); - } else if ( widenSecond && dynamic_cast< VoidType* >( refType->get_base() ) && ! isFtype(otherRef->get_base()) ) { + } else if ( widenSecond && dynamic_cast< VoidType * >( refType->get_base() ) && ! isFtype(otherRef->get_base()) ) { getCommonWithVoidPointer( refType, otherRef ); - } else if ( ( refType->get_base()->get_qualifiers() >= otherRef->get_base()->get_qualifiers() || widenFirst ) - && ( refType->get_base()->get_qualifiers() <= otherRef->get_base()->get_qualifiers() || widenSecond ) ) { + } else if ( ( refType->get_base()->tq >= otherRef->get_base()->tq || widenFirst ) + && ( refType->get_base()->tq <= otherRef->get_base()->tq || widenSecond ) ) { // std::cerr << "middle case" << std::endl; - Type::Qualifiers tq1 = refType->get_base()->get_qualifiers(), tq2 = otherRef->get_base()->get_qualifiers(); - refType->get_base()->get_qualifiers() = Type::Qualifiers(); - otherRef->get_base()->get_qualifiers() = Type::Qualifiers(); + Type::Qualifiers tq1 = refType->get_base()->tq, tq2 = otherRef->get_base()->tq; + refType->get_base()->tq = Type::Qualifiers(); + otherRef->get_base()->tq = Type::Qualifiers(); AssertionSet have, need; OpenVarSet newOpen( openVars ); @@ -579,14 +579,14 @@ result = otherRef->clone(); } // if - strict_dynamic_cast(result)->base->get_qualifiers() = tq1 | tq2; + strict_dynamic_cast(result)->base->tq = tq1 | tq2; } else { /// std::cerr << "place for ptr-to-type" << std::endl; } // if - refType->get_base()->get_qualifiers() = tq1; - otherRef->get_base()->get_qualifiers() = tq2; + refType->get_base()->tq = tq1; + otherRef->get_base()->tq = tq2; } // if - } else if ( widenSecond && dynamic_cast< ZeroType* >( type2 ) ) { + } else if ( widenSecond && dynamic_cast< ZeroType * >( type2 ) ) { result = refType->clone(); - result->get_qualifiers() |= type2->get_qualifiers(); + result->tq |= type2->tq; } // if } @@ -596,6 +596,6 @@ void CommonType_old::postvisit( UnionInstType * ) {} - void CommonType_old::postvisit( EnumInstType *enumInstType ) { - if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) { + void CommonType_old::postvisit( EnumInstType * enumInstType ) { + if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< ZeroType * >( type2 ) || dynamic_cast< OneType * >( type2 ) ) { // reuse BasicType, EnumInstType code by swapping type2 with enumInstType result = commonType( type2, enumInstType, widenSecond, widenFirst, indexer, env, openVars ); @@ -606,21 +606,21 @@ } - void CommonType_old::postvisit( TypeInstType *inst ) { + void CommonType_old::postvisit( TypeInstType * inst ) { if ( widenFirst ) { - NamedTypeDecl *nt = indexer.lookupType( inst->get_name() ); + const NamedTypeDecl * nt = indexer.lookupType( inst->get_name() ); if ( nt ) { - TypeDecl *type = strict_dynamic_cast< TypeDecl* >( nt ); + const TypeDecl * type = strict_dynamic_cast< const TypeDecl * >( nt ); if ( type->get_base() ) { - Type::Qualifiers tq1 = inst->get_qualifiers(), tq2 = type2->get_qualifiers(); + Type::Qualifiers tq1 = inst->tq, tq2 = type2->tq; AssertionSet have, need; OpenVarSet newOpen( openVars ); - type2->get_qualifiers() = Type::Qualifiers(); - type->get_base()->get_qualifiers() = tq1; + type2->tq = Type::Qualifiers(); + type->get_base()->tq = tq1; if ( unifyExact( type->get_base(), type2, env, have, need, newOpen, indexer ) ) { result = type2->clone(); - result->get_qualifiers() = tq1 | tq2; + result->tq = tq1 | tq2; } // if - type2->get_qualifiers() = tq2; - type->get_base()->get_qualifiers() = Type::Qualifiers(); + type2->tq = tq2; + type->get_base()->tq = Type::Qualifiers(); } // if } // if @@ -631,28 +631,28 @@ void CommonType_old::postvisit( VarArgsType * ) {} - void CommonType_old::postvisit( ZeroType *zeroType ) { + void CommonType_old::postvisit( ZeroType * zeroType ) { if ( widenFirst ) { - if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< PointerType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) { - if ( widenSecond || zeroType->get_qualifiers() <= type2->get_qualifiers() ) { + if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< PointerType * >( type2 ) || dynamic_cast< EnumInstType * >( type2 ) ) { + if ( widenSecond || zeroType->tq <= type2->tq ) { result = type2->clone(); - result->get_qualifiers() |= zeroType->get_qualifiers(); - } - } else if ( widenSecond && dynamic_cast< OneType* >( type2 ) ) { - result = new BasicType( zeroType->get_qualifiers(), BasicType::SignedInt ); - result->get_qualifiers() |= type2->get_qualifiers(); - } - } - } - - void CommonType_old::postvisit( OneType *oneType ) { + result->tq |= zeroType->tq; + } + } else if ( widenSecond && dynamic_cast< OneType * >( type2 ) ) { + result = new BasicType( zeroType->tq, BasicType::SignedInt ); + result->tq |= type2->tq; + } + } + } + + void CommonType_old::postvisit( OneType * oneType ) { if ( widenFirst ) { - if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) { - if ( widenSecond || oneType->get_qualifiers() <= type2->get_qualifiers() ) { + if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< EnumInstType * >( type2 ) ) { + if ( widenSecond || oneType->tq <= type2->tq ) { result = type2->clone(); - result->get_qualifiers() |= oneType->get_qualifiers(); - } - } else if ( widenSecond && dynamic_cast< ZeroType* >( type2 ) ) { - result = new BasicType( oneType->get_qualifiers(), BasicType::SignedInt ); - result->get_qualifiers() |= type2->get_qualifiers(); + result->tq |= oneType->tq; + } + } else if ( widenSecond && dynamic_cast< ZeroType * >( type2 ) ) { + result = new BasicType( oneType->tq, BasicType::SignedInt ); + result->tq |= type2->tq; } } @@ -668,6 +668,6 @@ ast::ptr< ast::Type > result; - CommonType_new( - const ast::Type * t2, WidenMode w, const ast::SymbolTable & st, + CommonType_new( + const ast::Type * t2, WidenMode w, const ast::SymbolTable & st, ast::TypeEnvironment & env, const ast::OpenVarSet & o ) : type2( t2 ), widen( w ), symtab( st ), tenv( env ), open( o ), result() {} @@ -681,14 +681,14 @@ #warning remove casts when `commonTypes` moved to new AST ast::BasicType::Kind kind = (ast::BasicType::Kind)(int)commonTypes[ (BasicType::Kind)(int)basic->kind ][ (BasicType::Kind)(int)basic2->kind ]; - if ( - ( ( kind == basic->kind && basic->qualifiers >= basic2->qualifiers ) - || widen.first ) - && ( ( kind == basic2->kind && basic->qualifiers <= basic2->qualifiers ) - || widen.second ) + if ( + ( ( kind == basic->kind && basic->qualifiers >= basic2->qualifiers ) + || widen.first ) + && ( ( kind == basic2->kind && basic->qualifiers <= basic2->qualifiers ) + || widen.second ) ) { result = new ast::BasicType{ kind, basic->qualifiers | basic2->qualifiers }; } - } else if ( - dynamic_cast< const ast::EnumInstType * >( type2 ) + } else if ( + dynamic_cast< const ast::EnumInstType * >( type2 ) || dynamic_cast< const ast::ZeroType * >( type2 ) || dynamic_cast< const ast::OneType * >( type2 ) @@ -696,9 +696,9 @@ #warning remove casts when `commonTypes` moved to new AST ast::BasicType::Kind kind = (ast::BasicType::Kind)(int)commonTypes[ (BasicType::Kind)(int)basic->kind ][ (BasicType::Kind)(int)ast::BasicType::SignedInt ]; - if ( - ( ( kind == basic->kind && basic->qualifiers >= type2->qualifiers ) - || widen.first ) - && ( ( kind != basic->kind && basic->qualifiers <= type2->qualifiers ) - || widen.second ) + if ( + ( ( kind == basic->kind && basic->qualifiers >= type2->qualifiers ) + || widen.first ) + && ( ( kind != basic->kind && basic->qualifiers <= type2->qualifiers ) + || widen.second ) ) { result = new ast::BasicType{ kind, basic->qualifiers | type2->qualifiers }; @@ -715,6 +715,6 @@ if ( entry != open.end() ) { ast::AssertionSet need, have; - if ( ! tenv.bindVar( - var, voidPtr->base, entry->second, need, have, open, widen, symtab ) + if ( ! tenv.bindVar( + var, voidPtr->base, entry->second, need, have, open, widen, symtab ) ) return; } @@ -727,14 +727,14 @@ void postvisit( const ast::PointerType * pointer ) { if ( auto pointer2 = dynamic_cast< const ast::PointerType * >( type2 ) ) { - if ( - widen.first - && pointer2->base.as< ast::VoidType >() - && ! ast::isFtype( pointer->base ) + if ( + widen.first + && pointer2->base.as< ast::VoidType >() + && ! ast::isFtype( pointer->base ) ) { getCommonWithVoidPointer( pointer2, pointer ); - } else if ( - widen.second - && pointer->base.as< ast::VoidType >() - && ! ast::isFtype( pointer2->base ) + } else if ( + widen.second + && pointer->base.as< ast::VoidType >() + && ! ast::isFtype( pointer2->base ) ) { getCommonWithVoidPointer( pointer, pointer2 ); @@ -746,10 +746,10 @@ ast::CV::Qualifiers q2 = pointer2->base->qualifiers; - // force t{1,2} to be cloned if their qualifiers must be stripped, so that + // force t{1,2} to be cloned if their qualifiers must be stripped, so that // pointer{,2}->base are unchanged ast::ptr< ast::Type > t1{ pointer->base }, t2{ pointer2->base }; reset_qualifiers( t1 ); reset_qualifiers( t2 ); - + ast::AssertionSet have, need; ast::OpenVarSet newOpen{ open }; @@ -758,6 +758,6 @@ if ( q1.val != q2.val ) { // reset result->base->qualifiers to be union of two base qualifiers - strict_dynamic_cast< ast::PointerType * >( - result.get_and_mutate() + strict_dynamic_cast< ast::PointerType * >( + result.get_and_mutate() )->base.get_and_mutate()->qualifiers = q1 | q2; } @@ -775,9 +775,9 @@ if ( auto ref2 = dynamic_cast< const ast::ReferenceType * >( type2 ) ) { if ( - widen.first && ref2->base.as< ast::VoidType >() && ! ast::isFtype( ref->base ) + widen.first && ref2->base.as< ast::VoidType >() && ! ast::isFtype( ref->base ) ) { getCommonWithVoidPointer( ref2, ref ); - } else if ( - widen.second && ref->base.as< ast::VoidType>() && ! ast::isFtype( ref2->base ) + } else if ( + widen.second && ref->base.as< ast::VoidType>() && ! ast::isFtype( ref2->base ) ) { getCommonWithVoidPointer( ref, ref2 ); @@ -788,5 +788,5 @@ ast::CV::Qualifiers q1 = ref->base->qualifiers, q2 = ref2->base->qualifiers; - // force t{1,2} to be cloned if their qualifiers must be stripped, so that + // force t{1,2} to be cloned if their qualifiers must be stripped, so that // ref{,2}->base are unchanged ast::ptr< ast::Type > t1{ ref->base }, t2{ ref2->base }; @@ -800,6 +800,6 @@ if ( q1.val != q2.val ) { // reset result->base->qualifiers to be union of two base qualifiers - strict_dynamic_cast< ast::ReferenceType * >( - result.get_and_mutate() + strict_dynamic_cast< ast::ReferenceType * >( + result.get_and_mutate() )->base.get_and_mutate()->qualifiers = q1 | q2; } @@ -819,6 +819,6 @@ void postvisit( const ast::EnumInstType * enumInst ) { - if ( - dynamic_cast< const ast::BasicType * >( type2 ) + if ( + dynamic_cast< const ast::BasicType * >( type2 ) || dynamic_cast< const ast::ZeroType * >( type2 ) || dynamic_cast< const ast::OneType * >( type2 ) @@ -834,6 +834,6 @@ if ( ! widen.first ) return; if ( const ast::NamedTypeDecl * nt = symtab.lookupType( inst->name ) ) { - if ( const ast::Type * base = - strict_dynamic_cast< const ast::TypeDecl * >( nt )->base + if ( const ast::Type * base = + strict_dynamic_cast< const ast::TypeDecl * >( nt )->base ) { ast::CV::Qualifiers q1 = inst->qualifiers, q2 = type2->qualifiers; @@ -860,5 +860,5 @@ void postvisit( const ast::ZeroType * zero ) { if ( ! widen.first ) return; - if ( + if ( dynamic_cast< const ast::BasicType * >( type2 ) || dynamic_cast< const ast::PointerType * >( type2 ) @@ -870,5 +870,5 @@ } } else if ( widen.second && dynamic_cast< const ast::OneType * >( type2 ) ) { - result = new ast::BasicType{ + result = new ast::BasicType{ ast::BasicType::SignedInt, zero->qualifiers | type2->qualifiers }; } @@ -877,5 +877,5 @@ void postvisit( const ast::OneType * one ) { if ( ! widen.first ) return; - if ( + if ( dynamic_cast< const ast::BasicType * >( type2 ) || dynamic_cast< const ast::EnumInstType * >( type2 ) @@ -886,5 +886,5 @@ } } else if ( widen.second && dynamic_cast< const ast::ZeroType * >( type2 ) ) { - result = new ast::BasicType{ + result = new ast::BasicType{ ast::BasicType::SignedInt, one->qualifiers | type2->qualifiers }; } @@ -894,8 +894,8 @@ namespace { - ast::ptr< ast::Type > handleReference( - const ast::ptr< ast::Type > & t1, const ast::ptr< ast::Type > & t2, WidenMode widen, - const ast::SymbolTable & symtab, ast::TypeEnvironment & env, - const ast::OpenVarSet & open + ast::ptr< ast::Type > handleReference( + const ast::ptr< ast::Type > & t1, const ast::ptr< ast::Type > & t2, WidenMode widen, + const ast::SymbolTable & symtab, ast::TypeEnvironment & env, + const ast::OpenVarSet & open ) { ast::ptr common; @@ -926,7 +926,7 @@ ast::ptr< ast::Type > commonType( - const ast::ptr< ast::Type > & type1, const ast::ptr< ast::Type > & type2, - WidenMode widen, const ast::SymbolTable & symtab, ast::TypeEnvironment & env, - const ast::OpenVarSet & open + const ast::ptr< ast::Type > & type1, const ast::ptr< ast::Type > & type2, + WidenMode widen, const ast::SymbolTable & symtab, ast::TypeEnvironment & env, + const ast::OpenVarSet & open ) { unsigned depth1 = type1->referenceDepth(); @@ -940,5 +940,5 @@ const ast::ReferenceType * ref1 = type1.as< ast::ReferenceType >(); const ast::ReferenceType * ref2 = type1.as< ast::ReferenceType >(); - + if ( depth1 > depth2 ) { assert( ref1 ); @@ -978,11 +978,11 @@ ast::OpenVarSet newOpen{ open }; - // force t{1,2} to be cloned if its qualifiers must be stripped, so that - // type1 and type->base are left unchanged; calling convention forces + // force t{1,2} to be cloned if its qualifiers must be stripped, so that + // type1 and type->base are left unchanged; calling convention forces // {type1,type->base}->strong_ref >= 1 ast::ptr t1{ type1 }, t2{ type->base }; reset_qualifiers( t1 ); reset_qualifiers( t2, q1 ); - + if ( unifyExact( t1, t2, env, have, need, newOpen, noWiden(), symtab ) ) { result = t1; Index: src/ResolvExpr/ConversionCost.cc =================================================================== --- src/ResolvExpr/ConversionCost.cc (revision 7870799883ca946218c97fb6a189d1da90a16e8e) +++ src/ResolvExpr/ConversionCost.cc (revision ef5b8288bd2be4816de42f8ea6a9b3d5e5971b31) @@ -49,5 +49,5 @@ if ( const TypeInstType * destAsTypeInst = dynamic_cast< const TypeInstType * >( dest ) ) { PRINT( std::cerr << "type inst " << destAsTypeInst->name; ) - if ( const EqvClass* eqvClass = env.lookup( destAsTypeInst->name ) ) { + if ( const EqvClass * eqvClass = env.lookup( destAsTypeInst->name ) ) { if ( eqvClass->type ) { return conversionCost( src, eqvClass->type, indexer, env ); @@ -57,5 +57,5 @@ } else if ( const NamedTypeDecl * namedType = indexer.lookupType( destAsTypeInst->name ) ) { PRINT( std::cerr << " found" << std::endl; ) - const TypeDecl *type = dynamic_cast< const TypeDecl* >( namedType ); + const TypeDecl * type = dynamic_cast< const TypeDecl * >( namedType ); // all typedefs should be gone by this point assert( type ); @@ -87,5 +87,5 @@ PassVisitor converter( dest, indexer, env, - (Cost (*)(const Type*, const Type*, const SymTab::Indexer&, const TypeEnvironment&)) + (Cost (*)(const Type *, const Type *, const SymTab::Indexer&, const TypeEnvironment&)) conversionCost ); src->accept( converter ); @@ -139,5 +139,5 @@ PassVisitor converter( dest, indexer, env, - (Cost (*)(const Type*, const Type*, const SymTab::Indexer&, const TypeEnvironment&)) + (Cost (*)(const Type *, const Type *, const SymTab::Indexer&, const TypeEnvironment&)) conversionCost ); src->accept( converter ); @@ -185,5 +185,5 @@ } - ConversionCost::ConversionCost( const Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc ) + ConversionCost::ConversionCost( const Type * dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc ) : dest( dest ), indexer( indexer ), cost( Cost::infinity ), env( env ), costFunc( costFunc ) { } @@ -218,45 +218,45 @@ static const int costMatrix[BasicType::NUMBER_OF_BASIC_TYPES][BasicType::NUMBER_OF_BASIC_TYPES] = { // path length from root to node /* B C SC UC SI SUI I UI LI LUI LLI LLUI IB UIB _FH _FH _F _FC F FC _FX _FXC FD _FDC D DC F80X_FDXC F80 _FB_FLDC FB LD LDC _FBX_FLDXC */ - /* B*/ { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 17, 16, 18, 17, }, - /* C*/ { -1, 0, 1, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 16, 15, 17, 16, }, - /* SC*/ { -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 16, 15, 17, 16, }, - /* UC*/ { -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 16, 15, 17, 16, }, - /* SI*/ { -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 15, 14, 16, 15, }, - /* SUI*/ { -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 15, 14, 16, 15, }, - /* I*/ { -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 14, 13, 15, 14, }, - /* UI*/ { -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 14, 13, 15, 14, }, - /* LI*/ { -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 13, 12, 14, 13, }, - /* LUI*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 13, 12, 14, 13, }, - /* LLI*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 12, 11, 13, 12, }, - /* LLUI*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 12, 11, 13, 12, }, - /* IB*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 11, 10, 12, 11, }, - /* UIB*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 11, 10, 12, 11, }, - /* _FH*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 10, 9, 11, 10, }, - /* _FH*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, -1, 2, -1, 3, -1, 4, -1, 5, -1, 6, -1, -1, 7, -1, -1, 8, -1, 9, }, - /* _F*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 9, 8, 10, 9, }, - /* _FC*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, -1, 2, -1, 3, -1, 4, -1, 5, -1, -1, 6, -1, -1, 7, -1, 8, }, - /* F*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 8, 7, 9, 8, }, - /* FC*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, -1, 2, -1, 3, -1, 4, -1, -1, 5, -1, -1, 6, -1, 7, }, - /* _FX*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 6, 8, 7, }, - /* _FXC*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, -1, 2, -1, 3, -1, -1, 4, -1, -1, 5, -1, 6, }, - /* FD*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 6, 5, 7, 6, }, - /* _FDC*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, -1, 2, -1, -1, 3, -1, -1, 4, -1, 5, }, - /* D*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 5, 4, 6, 5, }, - /* DC*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, -1, -1, 2, -1, -1, 3, -1, 4, }, - /* F80X*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 4, 3, 5, 4, }, - /* _FDXC*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, 1, -1, -1, 2, -1, 3, }, + /* B */ { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 17, 16, 18, 17, }, + /* C */ { -1, 0, 1, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 16, 15, 17, 16, }, + /* SC */ { -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 16, 15, 17, 16, }, + /* UC */ { -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 16, 15, 17, 16, }, + /* SI */ { -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 15, 14, 16, 15, }, + /* SUI */ { -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 15, 14, 16, 15, }, + /* I */ { -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 14, 13, 15, 14, }, + /* UI */ { -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 14, 13, 15, 14, }, + /* LI */ { -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 13, 12, 14, 13, }, + /* LUI */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 13, 12, 14, 13, }, + /* LLI */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 12, 11, 13, 12, }, + /* LLUI */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 12, 11, 13, 12, }, + /* IB */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 11, 10, 12, 11, }, + /* UIB */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 11, 10, 12, 11, }, + /* _FH */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 10, 9, 11, 10, }, + /* _FH */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, -1, 2, -1, 3, -1, 4, -1, 5, -1, 6, -1, -1, 7, -1, -1, 8, -1, 9, }, + /* _F */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 9, 8, 10, 9, }, + /* _FC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, -1, 2, -1, 3, -1, 4, -1, 5, -1, -1, 6, -1, -1, 7, -1, 8, }, + /* F */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 8, 7, 9, 8, }, + /* FC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, -1, 2, -1, 3, -1, 4, -1, -1, 5, -1, -1, 6, -1, 7, }, + /* _FX */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 6, 8, 7, }, + /* _FXC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, -1, 2, -1, 3, -1, -1, 4, -1, -1, 5, -1, 6, }, + /* FD */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 6, 5, 7, 6, }, + /* _FDC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, -1, 2, -1, -1, 3, -1, -1, 4, -1, 5, }, + /* D */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 5, 4, 6, 5, }, + /* DC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, -1, -1, 2, -1, -1, 3, -1, 4, }, + /* F80X */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 4, 3, 5, 4, }, + /* _FDXC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, 1, -1, -1, 2, -1, 3, }, /* F80*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 0, 1, 2, 2, 3, 3, 4, 4, }, - /* _FB*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, }, - /* _FLDC*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, 1, -1, 2, }, - /* FB*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 0, 1, 2, 2, 3, }, - /* LD*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, }, - /* LDC*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, }, - /* _FBX*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, }, - /*_FLDXC*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, }, + /* _FB */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, }, + /* _FLDC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, 1, -1, 2, }, + /* FB */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 0, 1, 2, 2, 3, }, + /* LD */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, }, + /* LDC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, }, + /* _FBX */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, }, + /* _FLDXC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, }, }; // costMatrix static const int maxIntCost = 15; // GENERATED END static_assert( - sizeof(costMatrix)/sizeof(costMatrix[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES, + sizeof(costMatrix)/sizeof(costMatrix[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES * BasicType::NUMBER_OF_BASIC_TYPES, "Missing row in the cost matrix" ); @@ -266,44 +266,44 @@ static const int signMatrix[BasicType::NUMBER_OF_BASIC_TYPES][BasicType::NUMBER_OF_BASIC_TYPES] = { // number of sign changes in safe conversion /* B C SC UC SI SUI I UI LI LUI LLI LLUI IB UIB _FH _FH _F _FC F FC _FX _FXC FD _FDC D DC F80X_FDXC F80 _FB_FLDC FB LD LDC _FBX_FLDXC */ - /* B*/ { 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, - /* C*/ { -1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, - /* SC*/ { -1, -1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, - /* UC*/ { -1, -1, -1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, - /* SI*/ { -1, -1, -1, -1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, - /* SUI*/ { -1, -1, -1, -1, -1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, - /* I*/ { -1, -1, -1, -1, -1, -1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, - /* UI*/ { -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, - /* LI*/ { -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, - /* LUI*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, - /* LLI*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, - /* LLUI*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, - /* IB*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, - /* UIB*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, - /* _FH*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, - /* _FH*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, }, - /* _F*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, - /* _FC*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, }, - /* F*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, - /* FC*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, }, - /* _FX*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, - /* _FXC*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, -1, 0, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, }, - /* FD*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, - /* _FDC*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, }, - /* D*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, - /* DC*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, }, - /* F80X*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, - /* _FDXC*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, }, + /* B */ { 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, + /* C */ { -1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, + /* SC */ { -1, -1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, + /* UC */ { -1, -1, -1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, + /* SI */ { -1, -1, -1, -1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, + /* SUI */ { -1, -1, -1, -1, -1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, + /* I */ { -1, -1, -1, -1, -1, -1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, + /* UI */ { -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, + /* LI */ { -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, + /* LUI */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, + /* LLI */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, + /* LLUI */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, + /* IB */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, + /* UIB */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, + /* _FH */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, + /* _FH */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, }, + /* _F */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, + /* _FC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, }, + /* F */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, + /* FC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, }, + /* _FX */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, + /* _FXC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, -1, 0, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, }, + /* FD */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, + /* _FDC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, }, + /* D */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, + /* DC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, }, + /* F80X */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, + /* _FDXC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, }, /* F80*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, - /* _FB*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, }, - /* _FLDC*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, 0, -1, 0, }, - /* FB*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, }, - /* LD*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, }, - /* LDC*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, }, - /* _FBX*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, }, - /*_FLDXC*/ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, }, + /* _FB */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, }, + /* _FLDC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, 0, -1, 0, }, + /* FB */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, }, + /* LD */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, }, + /* LDC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, }, + /* _FBX */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, }, + /* _FLDXC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, }, }; // signMatrix // GENERATED END static_assert( - sizeof(signMatrix)/sizeof(signMatrix[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES, + sizeof(signMatrix)/sizeof(signMatrix[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES * BasicType::NUMBER_OF_BASIC_TYPES, "Missing row in the sign matrix" ); @@ -313,6 +313,6 @@ } - void ConversionCost::postvisit(const BasicType *basicType) { - if ( const BasicType * destAsBasic = dynamic_cast< const BasicType* >( dest ) ) { + void ConversionCost::postvisit(const BasicType * basicType) { + if ( const BasicType * destAsBasic = dynamic_cast< const BasicType * >( dest ) ) { int tableResult = costMatrix[ basicType->kind ][ destAsBasic->kind ]; if ( tableResult == -1 ) { @@ -331,5 +331,5 @@ void ConversionCost::postvisit( const PointerType * pointerType ) { - if ( const PointerType *destAsPtr = dynamic_cast< const PointerType * >( dest ) ) { + if ( const PointerType * destAsPtr = dynamic_cast< const PointerType * >( dest ) ) { PRINT( std::cerr << pointerType << " ===> " << destAsPtr << std::endl; ) Type::Qualifiers tq1 = pointerType->base->tq; @@ -385,5 +385,5 @@ void ConversionCost::postvisit( const StructInstType * inst ) { - if ( const StructInstType *destAsInst = dynamic_cast< const StructInstType * >( dest ) ) { + if ( const StructInstType * destAsInst = dynamic_cast< const StructInstType * >( dest ) ) { if ( inst->name == destAsInst->name ) { cost = Cost::zero; @@ -393,5 +393,5 @@ void ConversionCost::postvisit( const UnionInstType * inst ) { - if ( const UnionInstType *destAsInst = dynamic_cast< const UnionInstType * >( dest ) ) { + if ( const UnionInstType * destAsInst = dynamic_cast< const UnionInstType * >( dest ) ) { if ( inst->name == destAsInst->name ) { cost = Cost::zero; @@ -411,13 +411,13 @@ void ConversionCost::postvisit( const TraitInstType * ) {} - void ConversionCost::postvisit( const TypeInstType *inst ) { - if ( const EqvClass *eqvClass = env.lookup( inst->name ) ) { + void ConversionCost::postvisit( const TypeInstType * inst ) { + if ( const EqvClass * eqvClass = env.lookup( inst->name ) ) { cost = costFunc( eqvClass->type, dest, indexer, env ); - } else if ( const TypeInstType *destAsInst = dynamic_cast< const TypeInstType* >( dest ) ) { + } else if ( const TypeInstType * destAsInst = dynamic_cast< const TypeInstType * >( dest ) ) { if ( inst->name == destAsInst->name ) { cost = Cost::zero; } - } else if ( NamedTypeDecl *namedType = indexer.lookupType( inst->name ) ) { - const TypeDecl *type = dynamic_cast< const TypeDecl* >( namedType ); + } else if ( const NamedTypeDecl * namedType = indexer.lookupType( inst->name ) ) { + const TypeDecl * type = dynamic_cast< const TypeDecl * >( namedType ); // all typedefs should be gone by this point assert( type ); @@ -434,5 +434,5 @@ std::list< Type * >::const_iterator destIt = destAsTuple->types.begin(); while ( srcIt != tupleType->types.end() && destIt != destAsTuple->types.end() ) { - Cost newCost = costFunc( *srcIt++, *destIt++, indexer, env ); + Cost newCost = costFunc( * srcIt++, * destIt++, indexer, env ); if ( newCost == Cost::infinity ) { return; @@ -449,5 +449,5 @@ void ConversionCost::postvisit( const VarArgsType * ) { - if ( dynamic_cast< const VarArgsType* >( dest ) ) { + if ( dynamic_cast< const VarArgsType * >( dest ) ) { cost = Cost::zero; } @@ -457,6 +457,6 @@ if ( dynamic_cast< const ZeroType * >( dest ) ) { cost = Cost::zero; - } else if ( const BasicType *destAsBasic = dynamic_cast< const BasicType* >( dest ) ) { - // copied from visit(BasicType*) for signed int, but +1 for safe conversions + } else if ( const BasicType * destAsBasic = dynamic_cast< const BasicType * >( dest ) ) { + // copied from visit(BasicType *) for signed int, but +1 for safe conversions int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->kind ]; if ( tableResult == -1 ) { @@ -467,5 +467,5 @@ cost.incSign( signMatrix[ BasicType::SignedInt ][ destAsBasic->kind ] ); } // if - } else if ( dynamic_cast< const PointerType* >( dest ) ) { + } else if ( dynamic_cast< const PointerType * >( dest ) ) { cost = Cost::zero; cost.incSafe( maxIntCost + 2 ); // +1 for zero_t -> int, +1 for disambiguation @@ -477,5 +477,5 @@ cost = Cost::zero; } else if ( const BasicType * destAsBasic = dynamic_cast< const BasicType * >( dest ) ) { - // copied from visit(BasicType*) for signed int, but +1 for safe conversions + // copied from visit(BasicType *) for signed int, but +1 for safe conversions int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->kind ]; if ( tableResult == -1 ) { @@ -729,5 +729,5 @@ auto dstEnd = dstAsTuple->types.end(); while ( srcIt != srcEnd && dstIt != dstEnd ) { - Cost newCost = costCalc( *srcIt++, *dstIt++, symtab, env ); + Cost newCost = costCalc( * srcIt++, * dstIt++, symtab, env ); if ( newCost == Cost::infinity ) { return; Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision 7870799883ca946218c97fb6a189d1da90a16e8e) +++ src/ResolvExpr/Resolver.cc (revision ef5b8288bd2be4816de42f8ea6a9b3d5e5971b31) @@ -562,6 +562,5 @@ // TODO: Replace *exception type with &exception type. if ( throwStmt->get_expr() ) { - StructDecl * exception_decl = - indexer.lookupStruct( "__cfaabi_ehm__base_exception_t" ); + StructDecl * exception_decl = indexer.lookupMutableStruct( "__cfaabi_ehm__base_exception_t" ); assert( exception_decl ); Type * exceptType = new PointerType( noQualifiers, new StructInstType( noQualifiers, exception_decl ) ); @@ -972,5 +971,5 @@ /// Calls the CandidateFinder and finds the single best candidate CandidateRef findUnfinishedKindExpression( - const ast::Expr * untyped, const ast::SymbolTable & symtab, const std::string & kind, + const ast::Expr * untyped, const ast::SymbolTable & symtab, const std::string & kind, std::function pred = anyCandidate, ResolvMode mode = {} ) { @@ -994,6 +993,6 @@ // produce invalid error if no candidates if ( candidates.empty() ) { - SemanticError( untyped, - toString( "No reasonable alternatives for ", kind, (kind != "" ? " " : ""), + SemanticError( untyped, + toString( "No reasonable alternatives for ", kind, (kind != "" ? " " : ""), "expression: ") ); } @@ -1031,5 +1030,5 @@ if ( winners.size() != 1 ) { std::ostringstream stream; - stream << "Cannot choose between " << winners.size() << " alternatives for " + stream << "Cannot choose between " << winners.size() << " alternatives for " << kind << (kind != "" ? " " : "") << "expression\n"; ast::print( stream, untyped ); @@ -1054,10 +1053,10 @@ struct StripCasts_new final { const ast::Expr * postmutate( const ast::CastExpr * castExpr ) { - if ( - castExpr->isGenerated - && typesCompatible( castExpr->arg->result, castExpr->result ) + if ( + castExpr->isGenerated + && typesCompatible( castExpr->arg->result, castExpr->result ) ) { // generated cast is the same type as its argument, remove it after keeping env - return ast::mutate_field( + return ast::mutate_field( castExpr->arg.get(), &ast::Expr::env, castExpr->env ); } @@ -1088,10 +1087,10 @@ /// Establish post-resolver invariants for expressions - void finishExpr( - ast::ptr< ast::Expr > & expr, const ast::TypeEnvironment & env, + void finishExpr( + ast::ptr< ast::Expr > & expr, const ast::TypeEnvironment & env, const ast::TypeSubstitution * oldenv = nullptr ) { // set up new type substitution for expression - ast::ptr< ast::TypeSubstitution > newenv = + ast::ptr< ast::TypeSubstitution > newenv = oldenv ? oldenv : new ast::TypeSubstitution{}; env.writeToSubstitution( *newenv.get_and_mutate() ); @@ -1102,15 +1101,15 @@ } // anonymous namespace - + ast::ptr< ast::Expr > resolveInVoidContext( const ast::Expr * expr, const ast::SymbolTable & symtab, ast::TypeEnvironment & env ) { assertf( expr, "expected a non-null expression" ); - + // set up and resolve expression cast to void ast::CastExpr * untyped = new ast::CastExpr{ expr }; - CandidateRef choice = findUnfinishedKindExpression( + CandidateRef choice = findUnfinishedKindExpression( untyped, symtab, "", anyCandidate, ResolvMode::withAdjustment() ); - + // a cast expression has either 0 or 1 interpretations (by language rules); // if 0, an exception has already been thrown, and this code will not run @@ -1122,7 +1121,7 @@ namespace { - /// Resolve `untyped` to the expression whose candidate is the best match for a `void` + /// Resolve `untyped` to the expression whose candidate is the best match for a `void` /// context. - ast::ptr< ast::Expr > findVoidExpression( + ast::ptr< ast::Expr > findVoidExpression( const ast::Expr * untyped, const ast::SymbolTable & symtab ) { @@ -1134,13 +1133,13 @@ } - /// resolve `untyped` to the expression whose candidate satisfies `pred` with the + /// resolve `untyped` to the expression whose candidate satisfies `pred` with the /// lowest cost, returning the resolved version ast::ptr< ast::Expr > findKindExpression( - const ast::Expr * untyped, const ast::SymbolTable & symtab, - std::function pred = anyCandidate, + const ast::Expr * untyped, const ast::SymbolTable & symtab, + std::function pred = anyCandidate, const std::string & kind = "", ResolvMode mode = {} ) { if ( ! untyped ) return {}; - CandidateRef choice = + CandidateRef choice = findUnfinishedKindExpression( untyped, symtab, kind, pred, mode ); finishExpr( choice->expr, choice->env, untyped->env ); @@ -1149,6 +1148,6 @@ /// Resolve `untyped` to the single expression whose candidate is the best match - ast::ptr< ast::Expr > findSingleExpression( - const ast::Expr * untyped, const ast::SymbolTable & symtab + ast::ptr< ast::Expr > findSingleExpression( + const ast::Expr * untyped, const ast::SymbolTable & symtab ) { return findKindExpression( untyped, symtab ); @@ -1170,9 +1169,9 @@ bool hasIntegralType( const Candidate & i ) { const ast::Type * type = i.expr->result; - + if ( auto bt = dynamic_cast< const ast::BasicType * >( type ) ) { return bt->isInteger(); - } else if ( - dynamic_cast< const ast::EnumInstType * >( type ) + } else if ( + dynamic_cast< const ast::EnumInstType * >( type ) || dynamic_cast< const ast::ZeroType * >( type ) || dynamic_cast< const ast::OneType * >( type ) @@ -1183,6 +1182,6 @@ /// Resolve `untyped` as an integral expression, returning the resolved version - ast::ptr< ast::Expr > findIntegralExpression( - const ast::Expr * untyped, const ast::SymbolTable & symtab + ast::ptr< ast::Expr > findIntegralExpression( + const ast::Expr * untyped, const ast::SymbolTable & symtab ) { return findKindExpression( untyped, symtab, hasIntegralType, "condition" ); @@ -1192,6 +1191,6 @@ bool isCharType( const ast::Type * t ) { if ( auto bt = dynamic_cast< const ast::BasicType * >( t ) ) { - return bt->kind == ast::BasicType::Char - || bt->kind == ast::BasicType::SignedChar + return bt->kind == ast::BasicType::Char + || bt->kind == ast::BasicType::SignedChar || bt->kind == ast::BasicType::UnsignedChar; } @@ -1253,6 +1252,6 @@ } - ast::ptr< ast::Init > resolveCtorInit( - const ast::ConstructorInit * ctorInit, const ast::SymbolTable & symtab + ast::ptr< ast::Init > resolveCtorInit( + const ast::ConstructorInit * ctorInit, const ast::SymbolTable & symtab ) { assert( ctorInit ); @@ -1261,6 +1260,6 @@ } - ast::ptr< ast::Expr > resolveStmtExpr( - const ast::StmtExpr * stmtExpr, const ast::SymbolTable & symtab + ast::ptr< ast::Expr > resolveStmtExpr( + const ast::StmtExpr * stmtExpr, const ast::SymbolTable & symtab ) { assert( stmtExpr ); @@ -1303,16 +1302,16 @@ void Resolver_new::previsit( const ast::ObjectDecl * objectDecl ) { - // To handle initialization of routine pointers [e.g. int (*fp)(int) = foo()], - // class-variable `initContext` is changed multiple times because the LHS is analyzed - // twice. The second analysis changes `initContext` because a function type can contain - // object declarations in the return and parameter types. Therefore each value of - // `initContext` is retained so the type on the first analysis is preserved and used for + // To handle initialization of routine pointers [e.g. int (*fp)(int) = foo()], + // class-variable `initContext` is changed multiple times because the LHS is analyzed + // twice. The second analysis changes `initContext` because a function type can contain + // object declarations in the return and parameter types. Therefore each value of + // `initContext` is retained so the type on the first analysis is preserved and used for // selecting the RHS. GuardValue( currentObject ); currentObject = ast::CurrentObject{ objectDecl->location, objectDecl->get_type() }; if ( inEnumDecl && dynamic_cast< const ast::EnumInstType * >( objectDecl->get_type() ) ) { - // enumerator initializers should not use the enum type to initialize, since the + // enumerator initializers should not use the enum type to initialize, since the // enum type is still incomplete at this point. Use `int` instead. - currentObject = ast::CurrentObject{ + currentObject = ast::CurrentObject{ objectDecl->location, new ast::BasicType{ ast::BasicType::SignedInt } }; } @@ -1325,9 +1324,9 @@ } - const ast::StaticAssertDecl * Resolver_new::previsit( - const ast::StaticAssertDecl * assertDecl + const ast::StaticAssertDecl * Resolver_new::previsit( + const ast::StaticAssertDecl * assertDecl ) { - return ast::mutate_field( - assertDecl, &ast::StaticAssertDecl::cond, + return ast::mutate_field( + assertDecl, &ast::StaticAssertDecl::cond, findIntegralExpression( assertDecl->cond, symtab ) ); } @@ -1338,6 +1337,6 @@ #warning should use new equivalent to Validate::SizeType rather than sizeType here ast::ptr< ast::Type > sizeType = new ast::BasicType{ ast::BasicType::LongUnsignedInt }; - ast::mutate_field( - type, &PtrType::dimension, + ast::mutate_field( + type, &PtrType::dimension, findSingleExpression( type->dimension, sizeType, symtab ) ); } @@ -1356,6 +1355,6 @@ visit_children = false; assertf( exprStmt->expr, "ExprStmt has null expression in resolver" ); - - return ast::mutate_field( + + return ast::mutate_field( exprStmt, &ast::ExprStmt::expr, findVoidExpression( exprStmt->expr, symtab ) ); } @@ -1364,12 +1363,12 @@ visit_children = false; - asmExpr = ast::mutate_field( + asmExpr = ast::mutate_field( asmExpr, &ast::AsmExpr::operand, findVoidExpression( asmExpr->operand, symtab ) ); - + if ( asmExpr->inout ) { asmExpr = ast::mutate_field( asmExpr, &ast::AsmExpr::inout, findVoidExpression( asmExpr->inout, symtab ) ); } - + return asmExpr; } @@ -1388,5 +1387,5 @@ const ast::WhileStmt * Resolver_new::previsit( const ast::WhileStmt * whileStmt ) { - return ast::mutate_field( + return ast::mutate_field( whileStmt, &ast::WhileStmt::cond, findIntegralExpression( whileStmt->cond, symtab ) ); } @@ -1409,5 +1408,5 @@ GuardValue( currentObject ); switchStmt = ast::mutate_field( - switchStmt, &ast::SwitchStmt::cond, + switchStmt, &ast::SwitchStmt::cond, findIntegralExpression( switchStmt->cond, symtab ) ); currentObject = ast::CurrentObject{ switchStmt->location, switchStmt->cond->result }; @@ -1420,15 +1419,15 @@ assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral " "expression." ); - - ast::ptr< ast::Expr > untyped = + + ast::ptr< ast::Expr > untyped = new ast::CastExpr{ caseStmt->location, caseStmt->cond, initAlts.front().type }; ast::ptr< ast::Expr > newExpr = findSingleExpression( untyped, symtab ); - - // case condition cannot have a cast in C, so it must be removed here, regardless of + + // case condition cannot have a cast in C, so it must be removed here, regardless of // whether it would perform a conversion. if ( const ast::CastExpr * castExpr = newExpr.as< ast::CastExpr >() ) { swap_and_save_env( newExpr, castExpr->arg ); } - + caseStmt = ast::mutate_field( caseStmt, &ast::CaseStmt::cond, newExpr ); } @@ -1443,5 +1442,5 @@ ast::ptr< ast::Type > target = new ast::PointerType{ new ast::VoidType{} }; branchStmt = ast::mutate_field( - branchStmt, &ast::BranchStmt::computedTarget, + branchStmt, &ast::BranchStmt::computedTarget, findSingleExpression( branchStmt->computedTarget, target, symtab ) ); } @@ -1453,5 +1452,5 @@ if ( returnStmt->expr ) { returnStmt = ast::mutate_field( - returnStmt, &ast::ReturnStmt::expr, + returnStmt, &ast::ReturnStmt::expr, findSingleExpression( returnStmt->expr, functionReturn, symtab ) ); } @@ -1462,11 +1461,11 @@ visit_children = false; if ( throwStmt->expr ) { - const ast::StructDecl * exceptionDecl = + const ast::StructDecl * exceptionDecl = symtab.lookupStruct( "__cfaabi_ehm__base_exception_t" ); assert( exceptionDecl ); - ast::ptr< ast::Type > exceptType = + ast::ptr< ast::Type > exceptType = new ast::PointerType{ new ast::StructInstType{ exceptionDecl } }; throwStmt = ast::mutate_field( - throwStmt, &ast::ThrowStmt::expr, + throwStmt, &ast::ThrowStmt::expr, findSingleExpression( throwStmt->expr, exceptType, symtab ) ); } @@ -1477,6 +1476,6 @@ if ( catchStmt->cond ) { ast::ptr< ast::Type > boolType = new ast::BasicType{ ast::BasicType::Bool }; - catchStmt = ast::mutate_field( - catchStmt, &ast::CatchStmt::cond, + catchStmt = ast::mutate_field( + catchStmt, &ast::CatchStmt::cond, findSingleExpression( catchStmt->cond, boolType, symtab ) ); } @@ -1506,12 +1505,12 @@ if ( clause.target.args.empty() ) { - SemanticError( stmt->location, + SemanticError( stmt->location, "Waitfor clause must have at least one mutex parameter"); } // Find all alternatives for all arguments in canonical form - std::vector< CandidateFinder > argFinders = + std::vector< CandidateFinder > argFinders = funcFinder.findSubExprs( clause.target.args ); - + // List all combinations of arguments std::vector< CandidateList > possibilities; @@ -1519,5 +1518,5 @@ // For every possible function: - // * try matching the arguments to the parameters, not the other way around because + // * try matching the arguments to the parameters, not the other way around because // more arguments than parameters CandidateList funcCandidates; @@ -1526,8 +1525,8 @@ for ( CandidateRef & func : funcFinder.candidates ) { try { - auto pointerType = dynamic_cast< const ast::PointerType * >( + auto pointerType = dynamic_cast< const ast::PointerType * >( func->expr->result->stripReferences() ); if ( ! pointerType ) { - SemanticError( stmt->location, func->expr->result.get(), + SemanticError( stmt->location, func->expr->result.get(), "candidate not viable: not a pointer type\n" ); } @@ -1535,5 +1534,5 @@ auto funcType = pointerType->base.as< ast::FunctionType >(); if ( ! funcType ) { - SemanticError( stmt->location, func->expr->result.get(), + SemanticError( stmt->location, func->expr->result.get(), "candidate not viable: not a function type\n" ); } @@ -1544,5 +1543,5 @@ if( ! nextMutex( param, paramEnd ) ) { - SemanticError( stmt->location, funcType, + SemanticError( stmt->location, funcType, "candidate function not viable: no mutex parameters\n"); } @@ -1560,5 +1559,5 @@ ast::AssertionSet need, have; ast::TypeEnvironment resultEnv{ func->env }; - // Add all type variables as open so that those not used in the + // Add all type variables as open so that those not used in the // parameter list are still considered open resultEnv.add( funcType->forall ); @@ -1580,5 +1579,5 @@ unsigned n_mutex_param = 0; - // For every argument of its set, check if it matches one of the + // For every argument of its set, check if it matches one of the // parameters. The order is important for ( auto & arg : argsList ) { @@ -1587,5 +1586,5 @@ // We ran out of parameters but still have arguments. // This function doesn't match - SemanticError( stmt->location, funcType, + SemanticError( stmt->location, funcType, toString("candidate function not viable: too many mutex " "arguments, expected ", n_mutex_param, "\n" ) ); @@ -1594,11 +1593,11 @@ ++n_mutex_param; - // Check if the argument matches the parameter type in the current + // Check if the argument matches the parameter type in the current // scope ast::ptr< ast::Type > paramType = (*param)->get_type(); - if ( - ! unify( - arg->expr->result, paramType, resultEnv, need, have, open, - symtab ) + if ( + ! unify( + arg->expr->result, paramType, resultEnv, need, have, open, + symtab ) ) { // Type doesn't match @@ -1627,7 +1626,7 @@ } while ( nextMutex( param, paramEnd ) ); - // We ran out of arguments but still have parameters left; this + // We ran out of arguments but still have parameters left; this // function doesn't match - SemanticError( stmt->location, funcType, + SemanticError( stmt->location, funcType, toString( "candidate function not viable: too few mutex " "arguments, expected ", n_mutex_param, "\n" ) ); @@ -1657,5 +1656,5 @@ // Make sure correct number of arguments if( funcCandidates.empty() ) { - SemanticErrorException top( stmt->location, + SemanticErrorException top( stmt->location, "No alternatives for function in call to waitfor" ); top.append( errors ); @@ -1664,6 +1663,6 @@ if( argsCandidates.empty() ) { - SemanticErrorException top( stmt->location, - "No alternatives for arguments in call to waitfor" ); + SemanticErrorException top( stmt->location, + "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; @@ -1671,5 +1670,5 @@ if( funcCandidates.size() > 1 ) { - SemanticErrorException top( stmt->location, + SemanticErrorException top( stmt->location, "Ambiguous function in call to waitfor" ); top.append( errors ); @@ -1686,7 +1685,7 @@ // build new clause ast::WaitForStmt::Clause clause2; - + clause2.target.func = funcCandidates.front()->expr; - + clause2.target.args.reserve( clause.target.args.size() ); for ( auto arg : argsCandidates.front() ) { @@ -1708,5 +1707,5 @@ ast::WaitForStmt::Timeout timeout2; - ast::ptr< ast::Type > target = + ast::ptr< ast::Type > target = new ast::BasicType{ ast::BasicType::LongLongUnsignedInt }; timeout2.time = findSingleExpression( stmt->timeout.time, target, symtab ); @@ -1740,7 +1739,7 @@ const ast::SingleInit * Resolver_new::previsit( const ast::SingleInit * singleInit ) { visit_children = false; - // resolve initialization using the possibilities as determined by the `currentObject` + // resolve initialization using the possibilities as determined by the `currentObject` // cursor. - ast::ptr< ast::Expr > untyped = new ast::UntypedInitExpr{ + ast::ptr< ast::Expr > untyped = new ast::UntypedInitExpr{ singleInit->location, singleInit->value, currentObject.getOptions() }; ast::ptr newExpr = findSingleExpression( untyped, symtab ); @@ -1751,6 +1750,6 @@ // discard InitExpr wrapper and retain relevant pieces. - // `initExpr` may have inferred params in the case where the expression specialized a - // function pointer, and newExpr may already have inferParams of its own, so a simple + // `initExpr` may have inferred params in the case where the expression specialized a + // function pointer, and newExpr may already have inferParams of its own, so a simple // swap is not sufficient ast::Expr::InferUnion inferred = initExpr->inferred; @@ -1758,5 +1757,5 @@ newExpr.get_and_mutate()->inferred.splice( std::move(inferred) ); - // get the actual object's type (may not exactly match what comes back from the resolver + // get the actual object's type (may not exactly match what comes back from the resolver // due to conversions) const ast::Type * initContext = currentObject.getCurrentType(); @@ -1770,5 +1769,5 @@ if ( auto pt = newExpr->result.as< ast::PointerType >() ) { if ( isCharType( pt->base ) ) { - // strip cast if we're initializing a char[] with a char* + // strip cast if we're initializing a char[] with a char* // e.g. char x[] = "hello" if ( auto ce = newExpr.as< ast::CastExpr >() ) { @@ -1793,8 +1792,8 @@ assert( listInit->designations.size() == listInit->initializers.size() ); for ( unsigned i = 0; i < listInit->designations.size(); ++i ) { - // iterate designations and initializers in pairs, moving the cursor to the current + // iterate designations and initializers in pairs, moving the cursor to the current // designated object and resolving the initializer against that object listInit = ast::mutate_field_index( - listInit, &ast::ListInit::designations, i, + listInit, &ast::ListInit::designations, i, currentObject.findNext( listInit->designations[i] ) ); listInit = ast::mutate_field_index( @@ -1818,6 +1817,6 @@ ctorInit = ast::mutate_field( ctorInit, &ast::ConstructorInit::init, nullptr ); - // intrinsic single-parameter constructors and destructors do nothing. Since this was - // implicitly generated, there's no way for it to have side effects, so get rid of it to + // intrinsic single-parameter constructors and destructors do nothing. Since this was + // implicitly generated, there's no way for it to have side effects, so get rid of it to // clean up generated code if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->ctor ) ) {