Changes in / [f632117:5c27b6a]


Ignore:
Files:
3 added
11 edited

Legend:

Unmodified
Added
Removed

  • src/ResolvExpr/CandidateFinder.cpp

    rf632117 r5c27b6a  
    906906                                }
    907907                                CandidateRef & choice = winners.front();
    908                                 choice->cost.incVar();
     908                                choice->cost.incSafe();
    909909                                candidates.emplace_back( std::move(choice) );
    910910                        }
    … …  
    13761376                        ast::Expr * newExpr = data.combine( nameExpr->location, cost );
    13771377
    1378                         bool bentConversion = false;
    1379                         if ( auto inst = newExpr->result.as<ast::EnumInstType>() ) {
    1380                                 if ( inst->base && inst->base->base ) {
    1381                                         bentConversion = true;
    1382                                 }
    1383                         }
    1384 
     1378                        // bool bentConversion = false;
     1379                        // if ( auto inst = newExpr->result.as<ast::EnumInstType>() ) {
     1380                        //      if ( inst->base && inst->base->base ) {
     1381                        //              bentConversion = true;
     1382                        //      }
     1383                        // }
     1384
     1385                        // CandidateRef newCand = std::make_shared<Candidate>(
     1386                        //      newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, bentConversion? Cost::safe: Cost::zero,
     1387                        //      cost );
    13851388                        CandidateRef newCand = std::make_shared<Candidate>(
    1386                                 newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, bentConversion? Cost::safe: Cost::zero,
     1389                                newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, Cost::zero,
    13871390                                cost );
    1388 
    13891391                        if (newCand->expr->env) {
    13901392                                newCand->env.add(*newCand->expr->env);
    … …  
    18291831                                        Cost cost = Cost::zero;
    18301832                                        ast::Expr * newExpr = data.combine( expr->location, cost );
     1833                                        // CandidateRef newCand =
     1834                                        //      std::make_shared<Candidate>(
     1835                                        //              newExpr, copy( tenv ), ast::OpenVarSet{},
     1836                                        //              ast::AssertionSet{}, Cost::safe, cost
     1837                                        //      );
    18311838                                        CandidateRef newCand =
    18321839                                                std::make_shared<Candidate>(
    18331840                                                        newExpr, copy( tenv ), ast::OpenVarSet{},
    1834                                                         ast::AssertionSet{}, Cost::safe, cost
     1841                                                        ast::AssertionSet{}, Cost::zero, cost
    18351842                                                );
    1836 
    18371843                                        if (newCand->expr->env) {
    18381844                                                newCand->env.add(*newCand->expr->env);

  • src/ResolvExpr/CastCost.cc

    rf632117 r5c27b6a  
    5353                        } else {
    5454                                cost = conversionCost( basicType, dst, srcIsLvalue, symtab, env );
     55                                if ( Cost::unsafe < cost ) {
     56                                        if (auto enumInst =  dynamic_cast<const ast::EnumInstType *>(dst)) {
     57                                                assert(enumInst->base->base);
     58                                                cost = Cost::unsafe;
     59                                        }
     60                                }
    5561                        }
     62                }
     63
     64                void postvisit( const ast::ZeroType * zero ) {
     65                        // auto ptr = dynamic_cast< const ast::PointerType * >( dst );
     66                        // if ( ptr && basicType->isInteger() ) {
     67                        //      // needed for, e.g. unsigned long => void *
     68                        //      cost = Cost::unsafe;
     69                        // } else {
     70                        cost = conversionCost( zero, dst, srcIsLvalue, symtab, env );
     71                        if ( Cost::unsafe < cost ) {
     72                                if (auto enumInst =  dynamic_cast<const ast::EnumInstType *>(dst)) {
     73                                        assert(enumInst->base->base);
     74                                        cost = Cost::unsafe;
     75                                }
     76                        }
     77                        // }
     78                }
     79
     80                void postvisit( const ast::OneType * one ) {
     81                        // auto ptr = dynamic_cast< const ast::PointerType * >( dst );
     82                        // if ( ptr && basicType->isInteger() ) {
     83                        //      // needed for, e.g. unsigned long => void *
     84                        //      cost = Cost::unsafe;
     85                        // } else {
     86                        cost = conversionCost( one, dst, srcIsLvalue, symtab, env );
     87                        if ( Cost::unsafe < cost ) {
     88                                if (auto enumInst =  dynamic_cast<const ast::EnumInstType *>(dst)) {
     89                                        assert(enumInst->base->base);
     90                                        cost = Cost::unsafe;
     91                                }
     92                        }
     93                        // }
    5694                }
    5795
    … …  
    80118                                        cost = Cost::unsafe;
    81119                                }
     120                        }
     121                }
     122
     123                void postvist( const ast::EnumInstType * ) {
     124                        if ( auto basic = dynamic_cast< const ast::BasicType * >(dst) ) {
     125                                if ( basic->isInteger() ) cost = Cost::unsafe;
    82126                        }
    83127                }

  • src/ResolvExpr/ConversionCost.cc

    rf632117 r5c27b6a  
    284284        } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
    285285                if ( dstAsEnumInst->base && !dstAsEnumInst->base->base ) {
    286                         cost = Cost::zero;
    287                         cost.incUnsafe();
     286                        cost = Cost::unsafe;
    288287                }
    289288        }
    … …  
    482481        } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
    483482                if ( dstAsEnumInst->base && !dstAsEnumInst->base->base ) {
    484                         cost = Cost::zero;
    485                         cost.incUnsafe();
     483                        cost = Cost::unsafe;
    486484                }
    487485        }
    … …  
    504502        } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
    505503                if ( dstAsEnumInst->base && !dstAsEnumInst->base->base ) {
    506                         cost = Cost::zero;
    507                         cost.incUnsafe();
     504                        cost = Cost::unsafe;
    508505                }
    509506        }

  • src/Validate/ImplementEnumFunc.cpp

    rf632117 r5c27b6a  
    3030        void genAttrFunctions();
    3131        void genSuccPredPosn();
    32         void genSuccPredDecl();
     32        // void genSuccPredDecl();
    3333
    3434        void appendReturnThis(ast::FunctionDecl* decl) {
    … …  
    7373        const ast::Decl* getDecl() const { return decl; }
    7474
     75        // Implement Bounded trait for enum
     76    void genBoundedFunctions();
     77        // Implement Serial trait for enum
     78        void genSerialTraitFuncs();
     79
     80        // Bounded trait
     81        ast::FunctionDecl* genLowerBoundProto() const;
     82        ast::FunctionDecl* genUpperBoundProto() const;
     83        void genLowerBoundBody(ast::FunctionDecl* func) const;
     84        void genUpperBoundBody(ast::FunctionDecl* func) const;
     85
    7586        ast::FunctionDecl* genPosnProto() const;
    7687        ast::FunctionDecl* genLabelProto() const;
    7788        ast::FunctionDecl* genValueProto() const;
     89
     90        // Serial trait
     91        ast::FunctionDecl* genFromIntProto() const;
     92        ast::FunctionDecl* genFromInstanceProto() const;
    7893        ast::FunctionDecl* genSuccProto() const;
    7994        ast::FunctionDecl* genPredProto() const;
     95
     96        void genFromIntBody(ast::FunctionDecl *) const;
     97        void genFromInstanceBody(ast::FunctionDecl *) const;
     98        ////////////////
    8099
    81100        ast::FunctionDecl* genSuccPosProto() const;
    … …  
    289308
    290309ast::FunctionDecl* EnumAttrFuncGenerator::genPosnProto() const {
    291         return genProto(
    292                 "posE",
    293                 {new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))},
    294                 {new ast::ObjectDecl(getLocation(), "_ret",
    295                         new ast::BasicType(ast::BasicKind::UnsignedInt))});
     310    return genProto(
     311        "posE",
     312        {new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))},
     313        {new ast::ObjectDecl(getLocation(), "_ret",
     314            new ast::BasicType(ast::BasicKind::UnsignedInt))});
    296315}
    297316
    … …  
    313332}
    314333
     334ast::FunctionDecl* EnumAttrFuncGenerator::genFromIntProto() const {
     335        return genProto(
     336                "fromInt",
     337                {new ast::ObjectDecl(getLocation(), "_i", new ast::BasicType(ast::BasicKind::UnsignedInt))},
     338                {new ast::ObjectDecl(getLocation(), "_ret", new ast::EnumInstType(decl))}
     339        );
     340}
     341
     342ast::FunctionDecl* EnumAttrFuncGenerator::genFromInstanceProto() const {
     343        return genProto(
     344                "fromInstance",
     345                {new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))},
     346                {new ast::ObjectDecl(getLocation(), "_ret", new ast::BasicType(ast::BasicKind::UnsignedInt))}
     347        );
     348}
     349
     350void EnumAttrFuncGenerator::genFromIntBody(ast::FunctionDecl* func) const {
     351        auto params = func->params;
     352        assert( params.size() == 1 );
     353        auto param = params.front();
     354        auto castExpr = new ast::CastExpr(
     355                func->location,
     356                new ast::VariableExpr(func->location, param),
     357                new ast::EnumInstType(decl),
     358                ast::GeneratedFlag::ExplicitCast
     359        );
     360        func->stmts = new ast::CompoundStmt(
     361                func->location, {new ast::ReturnStmt(func->location, castExpr)}
     362        );
     363}
     364
     365void EnumAttrFuncGenerator::genFromInstanceBody(ast::FunctionDecl* func) const {
     366        auto params = func->params;
     367        assert( params.size() == 1 );
     368        auto param = params.front();
     369        ast::UntypedExpr* untyped = ast::UntypedExpr::createCall(
     370                func->location, "posE", { new ast::VariableExpr(func->location, param) });
     371        func->stmts = new ast::CompoundStmt(
     372                func->location, {new ast::ReturnStmt(func->location, untyped)}
     373        );
     374}
     375
     376void EnumAttrFuncGenerator::genSerialTraitFuncs() {
     377        auto fromIntProto = genFromIntProto();
     378        produceForwardDecl(fromIntProto);
     379        genFromIntBody(fromIntProto);
     380        produceDecl(fromIntProto);
     381
     382        auto fromInstanceProto = genFromInstanceProto();
     383        produceForwardDecl(fromInstanceProto);
     384        genFromInstanceBody(fromInstanceProto);
     385        produceDecl(fromInstanceProto);
     386
     387        auto succProto = genSuccProto();
     388        auto predProto = genPredProto();
     389        produceForwardDecl(succProto);
     390        produceForwardDecl(predProto);
     391}
     392
    315393ast::FunctionDecl* EnumAttrFuncGenerator::genSuccProto() const {
    316394        return genProto(
    … …  
    327405                {new ast::ObjectDecl(getLocation(), "_ret",
    328406                                     new ast::EnumInstType(decl))});
     407}
     408
     409ast::FunctionDecl* EnumAttrFuncGenerator::genLowerBoundProto() const {
     410    return genProto("lowerBound", {}, {
     411        new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))
     412    });
     413}
     414
     415ast::FunctionDecl* EnumAttrFuncGenerator::genUpperBoundProto() const {
     416    return genProto("upperBound", {}, {
     417        new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))
     418    });
     419}
     420
     421void EnumAttrFuncGenerator::genLowerBoundBody(ast::FunctionDecl* func) const {
     422        const CodeLocation & loc = func->location;
     423        auto mem = decl->members.front();
     424        // auto expr = new ast::QualifiedNameExpr( loc, decl, mem->name );
     425        // expr->result = new ast::EnumInstType( decl );
     426        auto expr = new ast::NameExpr( loc, mem->name );
     427        func->stmts = new ast::CompoundStmt( loc, {new ast::ReturnStmt(loc, expr)});
     428}
     429
     430void EnumAttrFuncGenerator::genUpperBoundBody(ast::FunctionDecl* func) const {
     431        const CodeLocation & loc = func->location;
     432        auto mem = decl->members.back();
     433        auto expr = new ast::NameExpr( loc, mem->name );
     434        // expr->result = new ast::EnumInstType( decl );
     435        func->stmts = new ast::CompoundStmt( loc, {new ast::ReturnStmt(loc, expr)});   
     436}
     437
     438void EnumAttrFuncGenerator::genBoundedFunctions() {
     439        ast::FunctionDecl * upperDecl = genUpperBoundProto();
     440        produceForwardDecl(upperDecl);
     441        genUpperBoundBody(upperDecl);
     442        produceDecl(upperDecl);
     443
     444        ast::FunctionDecl * lowerDecl = genLowerBoundProto();
     445        produceForwardDecl(lowerDecl);
     446        genLowerBoundBody(lowerDecl);
     447        produceDecl(lowerDecl);
    329448}
    330449
    … …  
    373492                func->location, "?[?]",
    374493                {new ast::NameExpr(func->location, arrDecl->name),
    375                         new ast::CastExpr(
    376                                 func->location,
    377                                 new ast::VariableExpr( func->location, func->params.front() ),
    378                                 new ast::EnumAttrType( new ast::EnumInstType(decl),
    379                                         ast::EnumAttribute::Posn))});
     494                new ast::CastExpr(
     495                        func->location,
     496                        new ast::VariableExpr( func->location, func->params.front() ),
     497                        new ast::EnumAttrType( new ast::EnumInstType(decl),
     498                                ast::EnumAttribute::Posn))});
    380499        func->stmts = new ast::CompoundStmt(
    381500                func->location, {new ast::ReturnStmt(func->location, untyped)});
    … …  
    450569
    451570void EnumAttrFuncGenerator::genAttrFunctions() {
    452         if (decl->base) {
    453                 genAttributesDecls(ast::EnumAttribute::Value);
    454                 genAttributesDecls(ast::EnumAttribute::Label);
    455                 genAttributesDecls(ast::EnumAttribute::Posn);
    456         }
    457 }
    458 
    459 void EnumAttrFuncGenerator::genSuccPredDecl() {
    460         if (decl->base) {
    461                 auto succProto = genSuccProto();
    462                 auto predProto = genPredProto();
    463 
    464                 produceForwardDecl(succProto);
    465                 produceForwardDecl(predProto);
    466         }
    467 }
     571        genAttributesDecls(ast::EnumAttribute::Value);
     572        genAttributesDecls(ast::EnumAttribute::Label);
     573        genAttributesDecls(ast::EnumAttribute::Posn);   
     574}
     575
     576// void EnumAttrFuncGenerator::genSuccPredDecl() {
     577//      auto succProto = genSuccProto();
     578//      auto predProto = genPredProto();
     579
     580//      produceForwardDecl(succProto);
     581//      produceForwardDecl(predProto);
     582// }
    468583
    469584void EnumAttrFuncGenerator::genSuccPredPosn() {
    470         if (decl->base) {
    471                 ast::FunctionDecl* succ = genSuccPredFunc(true);
    472                 ast::FunctionDecl* pred = genSuccPredFunc(false);
    473 
    474                 produceDecl(succ);
    475                 produceDecl(pred);
    476         }
     585        ast::FunctionDecl* succ = genSuccPredFunc(true);
     586        ast::FunctionDecl* pred = genSuccPredFunc(false);
     587
     588        produceDecl(succ);
     589        produceDecl(pred);
    477590}
    478591
    … …  
    482595        genAttrStandardFuncs();
    483596        genAttrFunctions();
    484         genSuccPredDecl();
    485         genSuccPredPosn(); // Posn
     597        genSerialTraitFuncs();
     598        genSuccPredPosn();
     599        // problematic
     600        genBoundedFunctions();
    486601        // Now export the lists contents.
    487602        decls.splice(decls.end(), forwards);

  • src/main.cc

    rf632117 r5c27b6a  
    325325                PASS( "Validate Generic Parameters", Validate::fillGenericParameters, transUnit );
    326326                PASS( "Translate Dimensions", Validate::translateDimensionParameters, transUnit );
     327                // Need to happen before fixing returns because implementEnumFunc has ReturnStmt
     328               
     329                PASS( "Generate Enum Attributes Functions", Validate::implementEnumFunc, transUnit );
    327330                PASS( "Check Function Returns", Validate::checkReturnStatements, transUnit );
    328331                PASS( "Fix Return Statements", InitTweak::fixReturnStatements, transUnit );
    … …  
    333336
    334337                PASS( "Generate Autogen Routines", Validate::autogenerateRoutines, transUnit );
    335                 PASS( "Generate Enum Attributes Functions", Validate::implementEnumFunc, transUnit );
    336 
     338               
    337339                PASS( "Implement Actors", Concurrency::implementActors, transUnit );
    338340                PASS( "Implement Virtual Destructors", Virtual::implementVirtDtors, transUnit );

  • tests/enum_tests/.expect/stringEnum.txt

    rf632117 r5c27b6a  
    11zero: zero, one: one
     2zero: 0, one: 1

  • tests/enum_tests/anonymous.cfa

    rf632117 r5c27b6a  
    1 #include <stdio.h>
     1#include <fstream.hfa>
    22enum(unsigned long int ) { nthreads = 17 };
    33
    44int main() {
    5     printf("%lu", nthreads);
     5    sout | nthreads;
    66}
    77

  • tests/enum_tests/enumInlineValue.cfa

    rf632117 r5c27b6a  
    1212    enum enumB val = A;
    1313    sout | "enumB.A is" | val;
    14     enum enumB val2= enumB.B;
     14    enum enumB val2 = enumB.B;
    1515    sout | "enumB.B is" | val2;
    1616    sout | "enumB.D is" | enumB.D;

  • tests/enum_tests/position.cfa

    rf632117 r5c27b6a  
    1212
    1313int main () {
    14     Colour fishy; // posE()
    15     fishy = Colour.Green; // value(fishy) = Colour.Green;
    16     fishy; // valueE( fishy );
     14    Colour fishy;
     15    fishy = Colour.Green;
     16    fishy;
     17    Colour c2 = fishy;
    1718
    18     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 );
    19     printf( "Runtime: fishy value: %s, position: %d, label: %s, default return value: %s\n", valueE(fishy), posE(fishy), labelE(fishy), fishy );
    20     Colour c2 = fishy;
    21     printf( "Runtime: C2 value: %s, position: %d, label: %s, default return value: %s\n", valueE(c2), posE(c2), labelE(c2), c2 );
     19    sout | "Compile Time: blue value: " | valueE(Colour.Blue) | ", position: " | posE(Colour.Blue) | ", label: " | labelE(Colour.Blue) | ", default return value: " | Colour.Blue;
     20    sout | "Runtime: fishy value: " | valueE(fishy) | ", position: " | posE(fishy) | ", label: " | labelE(fishy) | ", default return value: " | fishy;
     21    sout | "Runtime: C2 value: " | valueE(c2) | ", position: " | posE(c2) | ", label: " | labelE(c2) | ", default return value: " | c2;
    2222    Colour.Red;
    2323    char * ao = Colour.Red;
    … …  
    2929    Plain a = B;
    3030    printf( "%d \n", a );
     31   
    3132}

  • tests/enum_tests/stringEnum.cfa

    rf632117 r5c27b6a  
     1#include <fstream.hfa>
    12#include <stdio.h>
    23
    … …  
    78
    89int main() {
    9     printf("zero: %s, one: %s\n", zero, one);
     10    sout | "zero: "| zero | ", one: " | one;
     11    printf("zero: %d, one: %d\n", zero, one);
    1012    return 0;
    1113}

  • tests/enum_tests/typedIntEnum.cfa

    rf632117 r5c27b6a  
    1 #include <stdio.h>
     1#include <fstream.hfa>
    22
    33enum(int) IntEnum {
    … …  
    1212
    1313int main() {
    14     printf("0=%d\n", zero);
    15     printf("1=%d\n", one);
    16     printf("1000=%d\n", thousand);
    17     printf("1001=%d\n", thousand_one);
    18     printf("2000=%d\n", two_thousand);
    19     printf("2001=%d\n", two_thousand_one);
    20     printf("2002=%d\n", two_thousand_two);
     14    sout | "0=" | zero;
     15    sout | "1=" | one;
     16    sout | "1000=" | thousand;
     17    sout | "1001=" | thousand_one;
     18    sout | "2000=" | two_thousand;
     19    sout | "2001=" | two_thousand_one;
     20    sout | "2002=" | two_thousand_two;
    2121    return 0;
    2222}
Note: See TracChangeset for help on using the changeset viewer.