Changes in / [d39d8a4:1e12f07]


Ignore:
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/enum.hfa

    rd39d8a4 r1e12f07  
    6666                return l;
    6767        }
     68
     69        E ?+=? ( E & l, one_t ) {
     70                l = succ(l);
     71                return l;
     72        }
     73       
     74        E ?-=? ( E & l, one_t ) {
     75                l = pred(l);
     76                return l;
     77        }
     78
     79        E ?+=? ( E & l, int i ) {
     80                int pos = posn(l) + i;
     81                return fromInt(pos);
     82        }
     83
     84        E ?-=? ( E & l, int i ) {
     85                int pos = posn(l) - i;
     86                return fromInt(pos);
     87        }
    6888       
    6989        E ?++( E & l ) {

  • src/ControlStruct/TranslateEnumRange.cpp

    rd39d8a4 r1e12f07  
    55
    66namespace ControlStruct {
    7 
    8 struct addInitType {
    9     const ast::Stmt * postvisit( const ast::ForStmt * stmt );
    10 };
    117
    128struct addInit {
    … …  
    1713    const ast::Stmt * postvisit( const ast::ForStmt * stmt );
    1814};
    19 
    20 const ast::Stmt* addInitType::postvisit( const ast::ForStmt * stmt ) {
    21     if ( stmt->range_over ) {
    22         auto typeExpr = stmt->range_over.strict_as<ast::TypeExpr>();
    23         auto type = typeExpr->type;
    24 
    25         auto objInit = stmt->inits.front();
    26         assert( stmt->inits.size() == 1 );
    27 
    28         if (auto declStmt = objInit.as<ast::DeclStmt>()) {
    29             auto decl = declStmt->decl;
    30             if ( auto objDecl = decl.as<ast::ObjectDecl>()) {
    31                 if ( !objDecl->type && type ) {
    32                     auto objDeclWithType = ast::mutate_field( objDecl, &ast::ObjectDecl::type, type );
    33                     auto declWithType = ast::mutate_field( declStmt, &ast::DeclStmt::decl, objDeclWithType );
    34                     stmt = ast::mutate_field_index( stmt, &ast::ForStmt::inits, 0, declWithType );
    35                 }
    36             }
    37         }
    38     }
    39     return stmt;
    40 }
    4115
    4216const ast::Stmt* addInit::postvisit( const ast::ForStmt * stmt ) {
    … …  
    8761    mut = ast::mutate_field(stmt, &ast::ForStmt::inc, assig );
    8862    return mut;
    89 }
     63} 
    9064
    9165void translateEnumRange( ast::TranslationUnit & translationUnit ) {

  • src/ResolvExpr/CandidateFinder.cpp

    rd39d8a4 r1e12f07  
    938938                        addAggMembers( unionInst, aggrExpr, *cand, Cost::unsafe, "" );
    939939                } else if ( auto enumInst = aggrExpr->result.as< ast::EnumInstType >() ) {
    940                         addEnumValueAsCandidate(enumInst, aggrExpr, Cost::unsafe);
     940                        addEnumValueAsCandidate( enumInst, aggrExpr, Cost::implicit );
    941941                }
    942942        }

  • src/ResolvExpr/Cost.hpp

    rd39d8a4 r1e12f07  
    3131                #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    3232                        // Little-endian => first value is low priority and last is high priority.
    33                         unsigned char padding;                                  ///< unused
    3433                        unsigned char referenceCost;                    ///< reference conversions
    3534                        unsigned char specCost;                                 ///< Polymorphic type specializations (type assertions), negative cost
    … …  
    3837                        unsigned char safeCost;                                 ///< Safe (widening) conversions
    3938                        unsigned char polyCost;                                 ///< Count of parameters and return values bound to some poly type
     39                        unsigned char implicitCost;                             ///< Aggregate implicit cost
    4040                        unsigned char unsafeCost;                               ///< Unsafe (narrowing) conversions
    4141                #else
    … …  
    4646        };
    4747        static const unsigned char correctb = 0xff;             // byte correction for negative spec cost
    48         static const uint64_t correctw = 0x00'00'00'00'00'ff'00'00; //' word correction for negative spec cost
     48        static const uint64_t correctw = 0x00'00'00'00'00'00'ff'00; //' word correction for negative spec cost
    4949  public:
    5050        // Compiler adjusts constants for correct endian.
    5151        enum : uint64_t {
    52                 zero      = 0x00'00'00'00'00'ff'00'00,
    53                 infinity  = 0xff'ff'ff'ff'ff'00'ff'ff,
    54                 unsafe    = 0x01'00'00'00'00'ff'00'00,
    55                 poly      = 0x00'01'00'00'00'ff'00'00,
    56                 safe      = 0x00'00'01'00'00'ff'00'00,
    57                 sign      = 0x00'00'00'01'00'ff'00'00,
    58                 var       = 0x00'00'00'00'01'ff'00'00,
    59                 spec      = 0x00'00'00'00'00'fe'00'00,
    60                 reference = 0x00'00'00'00'00'ff'01'00,
     52                zero      = 0x00'00'00'00'00'00'ff'00,
     53                infinity  = 0xff'ff'ff'ff'ff'ff'00'ff,
     54                unsafe    = 0x01'00'00'00'00'00'ff'00,
     55                implicit  = 0x00'01'00'00'01'00'ff'00,
     56                poly      = 0x00'00'01'00'00'00'ff'00,
     57                safe      = 0x00'00'00'01'00'00'ff'00,
     58                sign      = 0x00'00'00'00'01'00'ff'00,
     59                var       = 0x00'00'00'00'00'01'ff'00,
     60                spec      = 0x00'00'00'00'00'00'fe'00,
     61                reference = 0x00'00'00'00'00'00'ff'01,
    6162        }; //'
    6263
    6364        Cost( uint64_t all ) { Cost::all = all; }
    64         Cost( int unsafeCost, int polyCost, int safeCost, int signCost, int varCost, int specCost, int referenceCost ) {
     65        Cost( int unsafeCost, int polyCost, int safeCost, int signCost, int implicitCost, int varCost, int specCost, int referenceCost ) {
    6566                // Assume little-endian => first value is low priority and last is high priority.
    6667                v = {
    6768                #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    68                         (unsigned char)0,                                               // padding
    6969                        (unsigned char)referenceCost,                   // low priority
    7070                        (unsigned char)(specCost + correctb),   // correct for signedness
    … …  
    7373                        (unsigned char)safeCost,
    7474                        (unsigned char)polyCost,
     75                        (unsigned char)implicitCost,
    7576                        (unsigned char)unsafeCost,                              // high priority
    7677                #else
    … …  
    8182
    8283        int get_unsafeCost() const { return v.unsafeCost; }
     84        int get_implictCost() const { return v.implicitCost; }
    8385        int get_polyCost() const { return v.polyCost; }
    8486        int get_safeCost() const { return v.safeCost; }
    … …  
    112114        Cost incUnsafe( int inc = 1 ) {
    113115                if ( all != infinity ) { assert( v.unsafeCost + inc <= UCHAR_MAX ); v.unsafeCost += inc; }
     116                return *this;
     117        }
     118
     119        Cost incImplicit( int inc = 1 ) {
     120                if ( all != infinity ) { assert( v.implicitCost + inc <= UCHAR_MAX ); v.implicitCost += inc; }
    114121                return *this;
    115122        }
    … …  
    168175
    169176inline std::ostream & operator<<( std::ostream & os, const Cost cost ) {
    170         return os << "( " << cost.get_unsafeCost() << ", " << cost.get_polyCost() << ", " << cost.get_safeCost()
     177        return os << "( " << cost.get_unsafeCost() << ", " << cost.get_implictCost() << ", " << cost.get_polyCost() << ", " << cost.get_safeCost()
    171178                          << ", " << cost.get_signCost() << ", " << cost.get_varCost() << ", " << cost.get_specCost()
    172179                          << ", " << cost.get_referenceCost() << " )";

  • src/ResolvExpr/ResolveTypeof.cpp

    rd39d8a4 r1e12f07  
    130130        mutDecl->type = renameTyVars(mutDecl->type, RenameMode::GEN_EXPR_ID);
    131131        mutDecl->isTypeFixed = true;
     132
     133        auto enumInst = decl->type.as<ast::EnumInstType>();
     134        if ( enumInst && enumInst->base->isCfa ) {
     135                if ( auto init = decl->init.as<ast::SingleInit>() ) {
     136                        if ( auto initExpr = init->value.as<ast::ConstantExpr>() ) {
     137                                if ( initExpr->result.as<ast::ZeroType>() ) {
     138                                        auto newInit = new ast::SingleInit( init->location,
     139                                                ast::UntypedExpr::createCall( init->location, "lowerBound", {} )
     140                                        );
     141                                        mutDecl->init = newInit;
     142                                }
     143                        }
     144                }
     145        }
     146
    132147        return mutDecl;
    133148}

  • tests/.expect/castError.txt

    rd39d8a4 r1e12f07  
    66... with resolved type:
    77  char Alternatives are:
    8 Cost ( 1, 0, 0, 0, 0, 0, 0 ): Explicit Cast of:
     8Cost ( 1, 0, 0, 0, 0, 0, 0, 0 ): Explicit Cast of:
    99      Variable Expression: f: double
    1010      ... with resolved type:
    … …  
    1919  Environment:
    2020
    21 Cost ( 1, 0, 0, 0, 0, 0, 0 ): Explicit Cast of:
     21Cost ( 1, 0, 0, 0, 0, 0, 0, 0 ): Explicit Cast of:
    2222      Variable Expression: f: function
    2323        accepting unspecified arguments
    … …  
    3838  Environment:
    3939
    40 Cost ( 1, 0, 0, 0, 0, 0, 0 ): Explicit Cast of:
     40Cost ( 1, 0, 0, 0, 0, 0, 0, 0 ): Explicit Cast of:
    4141      Variable Expression: f: signed int
    4242      ... with resolved type:
    … …  
    6262... with resolved type:
    6363  void Alternatives are:
    64 Cost ( 0, 0, 2, 0, 0, 0, 0 ): Generated Cast of:
     64Cost ( 0, 0, 0, 2, 0, 0, 0, 0 ): Generated Cast of:
    6565      Comma Expression:
    6666        Constant Expression (3: signed int)
    … …  
    8080  Environment:
    8181
    82 Cost ( 0, 0, 2, 0, 0, 0, 0 ): Generated Cast of:
     82Cost ( 0, 0, 0, 2, 0, 0, 0, 0 ): Generated Cast of:
    8383      Comma Expression:
    8484        Constant Expression (3: signed int)

  • tests/errors/.expect/completeType.x64.txt

    rd39d8a4 r1e12f07  
    99... with resolved type:
    1010  void Alternatives are:
    11 Cost ( 0, 1, 2, 0, 1, -1, 0 ): Generated Cast of:
     11Cost ( 0, 0, 1, 2, 0, 1, -1, 0 ): Generated Cast of:
    1212      Application of
    1313        Variable Expression: *?: forall
    … …  
    4444
    4545
    46 Cost ( 0, 1, 2, 0, 1, -1, 0 ): Generated Cast of:
     46Cost ( 0, 0, 1, 2, 0, 1, -1, 0 ): Generated Cast of:
    4747      Application of
    4848        Variable Expression: *?: forall
    … …  
    111111
    112112      Unsatisfiable alternative:
    113 Cost ( 0, 1, 0, 0, 1, -5, 0 ): Application of
     113Cost ( 0, 0, 1, 0, 0, 1, -5, 0 ): Application of
    114114            Variable Expression: baz: forall
    115115              instance of type T (not function type)

  • tests/meta/.expect/arch.x64.txt

    rd39d8a4 r1e12f07  
    66... with resolved type:
    77  char Alternatives are:
    8 Cost ( 1, 0, 0, 0, 0, 0, 0 ): Explicit Cast of:
     8Cost ( 1, 0, 0, 0, 0, 0, 0, 0 ): Explicit Cast of:
    99      Variable Expression: FX64: double
    1010      ... with resolved type:
    … …  
    1919  Environment:
    2020
    21 Cost ( 1, 0, 0, 0, 0, 0, 0 ): Explicit Cast of:
     21Cost ( 1, 0, 0, 0, 0, 0, 0, 0 ): Explicit Cast of:
    2222      Variable Expression: FX64: function
    2323        accepting unspecified arguments
    … …  
    3838  Environment:
    3939
    40 Cost ( 1, 0, 0, 0, 0, 0, 0 ): Explicit Cast of:
     40Cost ( 1, 0, 0, 0, 0, 0, 0, 0 ): Explicit Cast of:
    4141      Variable Expression: FX64: signed int
    4242      ... with resolved type:
Note: See TracChangeset for help on using the changeset viewer.