Index: src/ResolvExpr/CandidateFinder.cpp =================================================================== --- src/ResolvExpr/CandidateFinder.cpp (revision caaf42482af35f2adb688307eb1ff6d29c000060) +++ src/ResolvExpr/CandidateFinder.cpp (revision 69867ad96034bafb80e5def900a2b21ff46090b9) @@ -906,5 +906,5 @@ } CandidateRef & choice = winners.front(); - choice->cost.incVar(); + choice->cost.incSafe(); candidates.emplace_back( std::move(choice) ); } @@ -1376,15 +1376,17 @@ ast::Expr * newExpr = data.combine( nameExpr->location, cost ); - bool bentConversion = false; - if ( auto inst = newExpr->result.as() ) { - if ( inst->base && inst->base->base ) { - bentConversion = true; - } - } - + // bool bentConversion = false; + // if ( auto inst = newExpr->result.as() ) { + // if ( inst->base && inst->base->base ) { + // bentConversion = true; + // } + // } + + // CandidateRef newCand = std::make_shared( + // newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, bentConversion? Cost::safe: Cost::zero, + // cost ); CandidateRef newCand = std::make_shared( - newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, bentConversion? Cost::safe: Cost::zero, + newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, Cost::zero, cost ); - if (newCand->expr->env) { newCand->env.add(*newCand->expr->env); @@ -1829,10 +1831,14 @@ Cost cost = Cost::zero; ast::Expr * newExpr = data.combine( expr->location, cost ); + // CandidateRef newCand = + // std::make_shared( + // newExpr, copy( tenv ), ast::OpenVarSet{}, + // ast::AssertionSet{}, Cost::safe, cost + // ); CandidateRef newCand = std::make_shared( newExpr, copy( tenv ), ast::OpenVarSet{}, - ast::AssertionSet{}, Cost::safe, cost + ast::AssertionSet{}, Cost::zero, cost ); - if (newCand->expr->env) { newCand->env.add(*newCand->expr->env); Index: src/ResolvExpr/CastCost.cc =================================================================== --- src/ResolvExpr/CastCost.cc (revision caaf42482af35f2adb688307eb1ff6d29c000060) +++ src/ResolvExpr/CastCost.cc (revision 69867ad96034bafb80e5def900a2b21ff46090b9) @@ -53,5 +53,43 @@ } else { cost = conversionCost( basicType, dst, srcIsLvalue, symtab, env ); + if ( Cost::unsafe < cost ) { + if (auto enumInst = dynamic_cast(dst)) { + assert(enumInst->base->base); + cost = Cost::unsafe; + } + } } + } + + void postvisit( const ast::ZeroType * zero ) { + // auto ptr = dynamic_cast< const ast::PointerType * >( dst ); + // if ( ptr && basicType->isInteger() ) { + // // needed for, e.g. unsigned long => void * + // cost = Cost::unsafe; + // } else { + cost = conversionCost( zero, dst, srcIsLvalue, symtab, env ); + if ( Cost::unsafe < cost ) { + if (auto enumInst = dynamic_cast(dst)) { + assert(enumInst->base->base); + cost = Cost::unsafe; + } + } + // } + } + + void postvisit( const ast::OneType * one ) { + // auto ptr = dynamic_cast< const ast::PointerType * >( dst ); + // if ( ptr && basicType->isInteger() ) { + // // needed for, e.g. unsigned long => void * + // cost = Cost::unsafe; + // } else { + cost = conversionCost( one, dst, srcIsLvalue, symtab, env ); + if ( Cost::unsafe < cost ) { + if (auto enumInst = dynamic_cast(dst)) { + assert(enumInst->base->base); + cost = Cost::unsafe; + } + } + // } } @@ -80,4 +118,10 @@ cost = Cost::unsafe; } + } + } + + void postvist( const ast::EnumInstType * ) { + if ( auto basic = dynamic_cast< const ast::BasicType * >(dst) ) { + if ( basic->isInteger() ) cost = Cost::unsafe; } } Index: src/ResolvExpr/ConversionCost.cc =================================================================== --- src/ResolvExpr/ConversionCost.cc (revision caaf42482af35f2adb688307eb1ff6d29c000060) +++ src/ResolvExpr/ConversionCost.cc (revision 69867ad96034bafb80e5def900a2b21ff46090b9) @@ -284,6 +284,5 @@ } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) { if ( dstAsEnumInst->base && !dstAsEnumInst->base->base ) { - cost = Cost::zero; - cost.incUnsafe(); + cost = Cost::unsafe; } } @@ -482,6 +481,5 @@ } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) { if ( dstAsEnumInst->base && !dstAsEnumInst->base->base ) { - cost = Cost::zero; - cost.incUnsafe(); + cost = Cost::unsafe; } } @@ -504,6 +502,5 @@ } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) { if ( dstAsEnumInst->base && !dstAsEnumInst->base->base ) { - cost = Cost::zero; - cost.incUnsafe(); + cost = Cost::unsafe; } } Index: src/Validate/HoistStruct.cpp =================================================================== --- src/Validate/HoistStruct.cpp (revision caaf42482af35f2adb688307eb1ff6d29c000060) +++ src/Validate/HoistStruct.cpp (revision 69867ad96034bafb80e5def900a2b21ff46090b9) @@ -27,4 +27,5 @@ namespace { +/// Is this a declaration can appear in a struct/union and should be hoisted? bool shouldHoist( ast::Decl const * decl ) { return dynamic_cast< ast::StructDecl const * >( decl ) @@ -34,8 +35,35 @@ } -/* This pass also does some renaming and internal field alteration, but the - * complex part is the actual hoisting. Hoisted declarations should always +/// Helper that updates an InstType if the base name could be updated. +template +InstType const * preInstType( InstType const * type ) { + assert( type->base ); + if ( nullptr == type->base->parent ) return type; + auto mut = ast::mutate( type ); + mut->name = mut->base->name; + return mut; +} + +/// Update StructInstType and UnionInstType names. +struct NameUpdater { + ast::StructInstType const * previsit( ast::StructInstType const * type ) { + return preInstType( type ); + } + + ast::UnionInstType const * previsit( ast::UnionInstType const * type ) { + return preInstType( type ); + } +}; + +ast::Decl const * updateNames( ast::Decl const * decl ) { + ast::Pass visitor; + return decl->accept( visitor ); +} + +/* This pass hoists from structs/unions. Hoisted declarations should always * appear before the declaration they are hoisted out of and if two types are * nested in the same declaration their order should not change. + * It also sets up parent relationships, does name mangling of hoisted types + * and updates instance types of the hoisted types. */ struct HoistStructCore final : @@ -96,5 +124,4 @@ auto mut = ast::mutate( decl ); mut->parent = parent; - mut->name = qualifiedName( mut ); extendParams( mut->params, parent->params ); decl = mut; @@ -116,4 +143,18 @@ } } + // Is this a nested type? Then update the name, after the parent's name + // has been updated (hence the post visit). + if ( mut->parent ) { + mut->name = qualifiedName( mut ); + // Top level type that has hoisted? Then do a second pass subpass to make + // sure we update instance type names after the declaration is renamed. + } else if ( !declsToAddBefore.empty() ) { + for ( ast::ptr & member : mut->members ) { + member = updateNames( member.get() ); + } + for ( ast::ptr & declToAdd : declsToAddBefore ) { + declToAdd = updateNames( declToAdd ); + } + } return mut; } @@ -167,12 +208,4 @@ } -template -InstType const * preInstType( InstType const * type ) { - assert( type->base ); - auto mut = ast::mutate( type ); - mut->name = mut->base->name; - return mut; -} - ast::StructInstType const * HoistStructCore::previsit( ast::StructInstType const * type ) { return preInstType( preCollectionInstType( type ) ); Index: src/Validate/ImplementEnumFunc.cpp =================================================================== --- src/Validate/ImplementEnumFunc.cpp (revision caaf42482af35f2adb688307eb1ff6d29c000060) +++ src/Validate/ImplementEnumFunc.cpp (revision 69867ad96034bafb80e5def900a2b21ff46090b9) @@ -30,5 +30,5 @@ void genAttrFunctions(); void genSuccPredPosn(); - void genSuccPredDecl(); + // void genSuccPredDecl(); void appendReturnThis(ast::FunctionDecl* decl) { @@ -73,9 +73,28 @@ const ast::Decl* getDecl() const { return decl; } + // Implement Bounded trait for enum + void genBoundedFunctions(); + // Implement Serial trait for enum + void genSerialTraitFuncs(); + + // Bounded trait + ast::FunctionDecl* genLowerBoundProto() const; + ast::FunctionDecl* genUpperBoundProto() const; + void genLowerBoundBody(ast::FunctionDecl* func) const; + void genUpperBoundBody(ast::FunctionDecl* func) const; + ast::FunctionDecl* genPosnProto() const; ast::FunctionDecl* genLabelProto() const; ast::FunctionDecl* genValueProto() const; + + // Serial trait + ast::FunctionDecl* genFromIntProto() const; + ast::FunctionDecl* genFromInstanceProto() const; ast::FunctionDecl* genSuccProto() const; ast::FunctionDecl* genPredProto() const; + + void genFromIntBody(ast::FunctionDecl *) const; + void genFromInstanceBody(ast::FunctionDecl *) const; + //////////////// ast::FunctionDecl* genSuccPosProto() const; @@ -289,9 +308,9 @@ ast::FunctionDecl* EnumAttrFuncGenerator::genPosnProto() const { - return genProto( - "posE", - {new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))}, - {new ast::ObjectDecl(getLocation(), "_ret", - new ast::BasicType(ast::BasicKind::UnsignedInt))}); + return genProto( + "posE", + {new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))}, + {new ast::ObjectDecl(getLocation(), "_ret", + new ast::BasicType(ast::BasicKind::UnsignedInt))}); } @@ -313,4 +332,63 @@ } +ast::FunctionDecl* EnumAttrFuncGenerator::genFromIntProto() const { + return genProto( + "fromInt", + {new ast::ObjectDecl(getLocation(), "_i", new ast::BasicType(ast::BasicKind::UnsignedInt))}, + {new ast::ObjectDecl(getLocation(), "_ret", new ast::EnumInstType(decl))} + ); +} + +ast::FunctionDecl* EnumAttrFuncGenerator::genFromInstanceProto() const { + return genProto( + "fromInstance", + {new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))}, + {new ast::ObjectDecl(getLocation(), "_ret", new ast::BasicType(ast::BasicKind::UnsignedInt))} + ); +} + +void EnumAttrFuncGenerator::genFromIntBody(ast::FunctionDecl* func) const { + auto params = func->params; + assert( params.size() == 1 ); + auto param = params.front(); + auto castExpr = new ast::CastExpr( + func->location, + new ast::VariableExpr(func->location, param), + new ast::EnumInstType(decl), + ast::GeneratedFlag::ExplicitCast + ); + func->stmts = new ast::CompoundStmt( + func->location, {new ast::ReturnStmt(func->location, castExpr)} + ); +} + +void EnumAttrFuncGenerator::genFromInstanceBody(ast::FunctionDecl* func) const { + auto params = func->params; + assert( params.size() == 1 ); + auto param = params.front(); + ast::UntypedExpr* untyped = ast::UntypedExpr::createCall( + func->location, "posE", { new ast::VariableExpr(func->location, param) }); + func->stmts = new ast::CompoundStmt( + func->location, {new ast::ReturnStmt(func->location, untyped)} + ); +} + +void EnumAttrFuncGenerator::genSerialTraitFuncs() { + auto fromIntProto = genFromIntProto(); + produceForwardDecl(fromIntProto); + genFromIntBody(fromIntProto); + produceDecl(fromIntProto); + + auto fromInstanceProto = genFromInstanceProto(); + produceForwardDecl(fromInstanceProto); + genFromInstanceBody(fromInstanceProto); + produceDecl(fromInstanceProto); + + auto succProto = genSuccProto(); + auto predProto = genPredProto(); + produceForwardDecl(succProto); + produceForwardDecl(predProto); +} + ast::FunctionDecl* EnumAttrFuncGenerator::genSuccProto() const { return genProto( @@ -327,4 +405,45 @@ {new ast::ObjectDecl(getLocation(), "_ret", new ast::EnumInstType(decl))}); +} + +ast::FunctionDecl* EnumAttrFuncGenerator::genLowerBoundProto() const { + return genProto("lowerBound", {}, { + new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl)) + }); +} + +ast::FunctionDecl* EnumAttrFuncGenerator::genUpperBoundProto() const { + return genProto("upperBound", {}, { + new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl)) + }); +} + +void EnumAttrFuncGenerator::genLowerBoundBody(ast::FunctionDecl* func) const { + const CodeLocation & loc = func->location; + auto mem = decl->members.front(); + // auto expr = new ast::QualifiedNameExpr( loc, decl, mem->name ); + // expr->result = new ast::EnumInstType( decl ); + auto expr = new ast::NameExpr( loc, mem->name ); + func->stmts = new ast::CompoundStmt( loc, {new ast::ReturnStmt(loc, expr)}); +} + +void EnumAttrFuncGenerator::genUpperBoundBody(ast::FunctionDecl* func) const { + const CodeLocation & loc = func->location; + auto mem = decl->members.back(); + auto expr = new ast::NameExpr( loc, mem->name ); + // expr->result = new ast::EnumInstType( decl ); + func->stmts = new ast::CompoundStmt( loc, {new ast::ReturnStmt(loc, expr)}); +} + +void EnumAttrFuncGenerator::genBoundedFunctions() { + ast::FunctionDecl * upperDecl = genUpperBoundProto(); + produceForwardDecl(upperDecl); + genUpperBoundBody(upperDecl); + produceDecl(upperDecl); + + ast::FunctionDecl * lowerDecl = genLowerBoundProto(); + produceForwardDecl(lowerDecl); + genLowerBoundBody(lowerDecl); + produceDecl(lowerDecl); } @@ -373,9 +492,9 @@ func->location, "?[?]", {new ast::NameExpr(func->location, arrDecl->name), - new ast::CastExpr( - func->location, - new ast::VariableExpr( func->location, func->params.front() ), - new ast::EnumAttrType( new ast::EnumInstType(decl), - ast::EnumAttribute::Posn))}); + new ast::CastExpr( + func->location, + new ast::VariableExpr( func->location, func->params.front() ), + new ast::EnumAttrType( new ast::EnumInstType(decl), + ast::EnumAttribute::Posn))}); func->stmts = new ast::CompoundStmt( func->location, {new ast::ReturnStmt(func->location, untyped)}); @@ -450,29 +569,23 @@ void EnumAttrFuncGenerator::genAttrFunctions() { - if (decl->base) { - genAttributesDecls(ast::EnumAttribute::Value); - genAttributesDecls(ast::EnumAttribute::Label); - genAttributesDecls(ast::EnumAttribute::Posn); - } -} - -void EnumAttrFuncGenerator::genSuccPredDecl() { - if (decl->base) { - auto succProto = genSuccProto(); - auto predProto = genPredProto(); - - produceForwardDecl(succProto); - produceForwardDecl(predProto); - } -} + genAttributesDecls(ast::EnumAttribute::Value); + genAttributesDecls(ast::EnumAttribute::Label); + genAttributesDecls(ast::EnumAttribute::Posn); +} + +// void EnumAttrFuncGenerator::genSuccPredDecl() { +// auto succProto = genSuccProto(); +// auto predProto = genPredProto(); + +// produceForwardDecl(succProto); +// produceForwardDecl(predProto); +// } void EnumAttrFuncGenerator::genSuccPredPosn() { - if (decl->base) { - ast::FunctionDecl* succ = genSuccPredFunc(true); - ast::FunctionDecl* pred = genSuccPredFunc(false); - - produceDecl(succ); - produceDecl(pred); - } + ast::FunctionDecl* succ = genSuccPredFunc(true); + ast::FunctionDecl* pred = genSuccPredFunc(false); + + produceDecl(succ); + produceDecl(pred); } @@ -482,6 +595,8 @@ genAttrStandardFuncs(); genAttrFunctions(); - genSuccPredDecl(); - genSuccPredPosn(); // Posn + genSerialTraitFuncs(); + genSuccPredPosn(); + // problematic + genBoundedFunctions(); // Now export the lists contents. decls.splice(decls.end(), forwards); Index: src/main.cc =================================================================== --- src/main.cc (revision caaf42482af35f2adb688307eb1ff6d29c000060) +++ src/main.cc (revision 69867ad96034bafb80e5def900a2b21ff46090b9) @@ -325,4 +325,7 @@ PASS( "Validate Generic Parameters", Validate::fillGenericParameters, transUnit ); PASS( "Translate Dimensions", Validate::translateDimensionParameters, transUnit ); + // Need to happen before fixing returns because implementEnumFunc has ReturnStmt + + PASS( "Generate Enum Attributes Functions", Validate::implementEnumFunc, transUnit ); PASS( "Check Function Returns", Validate::checkReturnStatements, transUnit ); PASS( "Fix Return Statements", InitTweak::fixReturnStatements, transUnit ); @@ -333,6 +336,5 @@ PASS( "Generate Autogen Routines", Validate::autogenerateRoutines, transUnit ); - PASS( "Generate Enum Attributes Functions", Validate::implementEnumFunc, transUnit ); - + PASS( "Implement Actors", Concurrency::implementActors, transUnit ); PASS( "Implement Virtual Destructors", Virtual::implementVirtDtors, transUnit ); Index: tests/enum_tests/.expect/anonymous.txt =================================================================== --- tests/enum_tests/.expect/anonymous.txt (revision caaf42482af35f2adb688307eb1ff6d29c000060) +++ tests/enum_tests/.expect/anonymous.txt (revision 69867ad96034bafb80e5def900a2b21ff46090b9) Index: tests/enum_tests/.expect/funcEnum.txt =================================================================== --- tests/enum_tests/.expect/funcEnum.txt (revision 69867ad96034bafb80e5def900a2b21ff46090b9) +++ tests/enum_tests/.expect/funcEnum.txt (revision 69867ad96034bafb80e5def900a2b21ff46090b9) @@ -0,0 +1,1 @@ +5 Index: tests/enum_tests/.expect/position.txt =================================================================== --- tests/enum_tests/.expect/position.txt (revision 69867ad96034bafb80e5def900a2b21ff46090b9) +++ tests/enum_tests/.expect/position.txt (revision 69867ad96034bafb80e5def900a2b21ff46090b9) @@ -0,0 +1,7 @@ +Compile Time: blue value: blue, position: 2, label: Blue, default return value: blue +Runtime: fishy value: green, position: 1, label: Green, default return value: green +Runtime: C2 value: green, position: 1, label: Green, default return value: green +ao is red +ko is green +0, 1, 10, +1 Index: tests/enum_tests/.expect/stringEnum.txt =================================================================== --- tests/enum_tests/.expect/stringEnum.txt (revision caaf42482af35f2adb688307eb1ff6d29c000060) +++ tests/enum_tests/.expect/stringEnum.txt (revision 69867ad96034bafb80e5def900a2b21ff46090b9) @@ -1,1 +1,2 @@ zero: zero, one: one +zero: 0, one: 1 Index: tests/enum_tests/anonymous.cfa =================================================================== --- tests/enum_tests/anonymous.cfa (revision caaf42482af35f2adb688307eb1ff6d29c000060) +++ tests/enum_tests/anonymous.cfa (revision 69867ad96034bafb80e5def900a2b21ff46090b9) @@ -1,7 +1,7 @@ -#include +#include enum(unsigned long int ) { nthreads = 17 }; int main() { - printf("%lu", nthreads); + sout | nthreads; } Index: tests/enum_tests/enumInlineValue.cfa =================================================================== --- tests/enum_tests/enumInlineValue.cfa (revision caaf42482af35f2adb688307eb1ff6d29c000060) +++ tests/enum_tests/enumInlineValue.cfa (revision 69867ad96034bafb80e5def900a2b21ff46090b9) @@ -12,5 +12,5 @@ enum enumB val = A; sout | "enumB.A is" | val; - enum enumB val2= enumB.B; + enum enumB val2 = enumB.B; sout | "enumB.B is" | val2; sout | "enumB.D is" | enumB.D; Index: tests/enum_tests/position.cfa =================================================================== --- tests/enum_tests/position.cfa (revision caaf42482af35f2adb688307eb1ff6d29c000060) +++ tests/enum_tests/position.cfa (revision 69867ad96034bafb80e5def900a2b21ff46090b9) @@ -12,12 +12,12 @@ int main () { - Colour fishy; // posE() - fishy = Colour.Green; // value(fishy) = Colour.Green; - fishy; // valueE( fishy ); + Colour fishy; + fishy = Colour.Green; + fishy; + Colour c2 = fishy; - printf( "Compile Time: blue value: %s, position: %d, label: %s, default return value: %s \n", valueE(Colour.Blue), posE(Colour.Blue), labelE(Colour.Blue), Colour.Blue ); - printf( "Runtime: fishy value: %s, position: %d, label: %s, default return value: %s\n", valueE(fishy), posE(fishy), labelE(fishy), fishy ); - Colour c2 = fishy; - printf( "Runtime: C2 value: %s, position: %d, label: %s, default return value: %s\n", valueE(c2), posE(c2), labelE(c2), c2 ); + sout | "Compile Time: blue value: " | valueE(Colour.Blue) | ", position: " | posE(Colour.Blue) | ", label: " | labelE(Colour.Blue) | ", default return value: " | Colour.Blue; + sout | "Runtime: fishy value: " | valueE(fishy) | ", position: " | posE(fishy) | ", label: " | labelE(fishy) | ", default return value: " | fishy; + sout | "Runtime: C2 value: " | valueE(c2) | ", position: " | posE(c2) | ", label: " | labelE(c2) | ", default return value: " | c2; Colour.Red; char * ao = Colour.Red; @@ -29,3 +29,4 @@ Plain a = B; printf( "%d \n", a ); + } Index: tests/enum_tests/stringEnum.cfa =================================================================== --- tests/enum_tests/stringEnum.cfa (revision caaf42482af35f2adb688307eb1ff6d29c000060) +++ tests/enum_tests/stringEnum.cfa (revision 69867ad96034bafb80e5def900a2b21ff46090b9) @@ -1,2 +1,3 @@ +#include #include @@ -7,5 +8,6 @@ int main() { - printf("zero: %s, one: %s\n", zero, one); + sout | "zero: "| zero | ", one: " | one; + printf("zero: %d, one: %d\n", zero, one); return 0; } Index: tests/enum_tests/typedIntEnum.cfa =================================================================== --- tests/enum_tests/typedIntEnum.cfa (revision caaf42482af35f2adb688307eb1ff6d29c000060) +++ tests/enum_tests/typedIntEnum.cfa (revision 69867ad96034bafb80e5def900a2b21ff46090b9) @@ -1,3 +1,3 @@ -#include +#include enum(int) IntEnum { @@ -12,11 +12,11 @@ int main() { - printf("0=%d\n", zero); - printf("1=%d\n", one); - printf("1000=%d\n", thousand); - printf("1001=%d\n", thousand_one); - printf("2000=%d\n", two_thousand); - printf("2001=%d\n", two_thousand_one); - printf("2002=%d\n", two_thousand_two); + sout | "0=" | zero; + sout | "1=" | one; + sout | "1000=" | thousand; + sout | "1001=" | thousand_one; + sout | "2000=" | two_thousand; + sout | "2001=" | two_thousand_one; + sout | "2002=" | two_thousand_two; return 0; }