Changeset 4e08a54 for src


Ignore:
Timestamp:
Apr 19, 2024, 12:01:34 PM (17 months ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
master
Children:
b9b6efb
Parents:
da87eaf (diff), 02c80cdc (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:
src
Files:
3 added
49 edited

Legend:

Unmodified
Added
Removed

  • src/AST/Decl.cpp

    rda87eaf r4e08a54  
    169169}
    170170
     171const std::string EnumDecl::getUnmangeldArrayName( const ast::EnumAttribute attr ) const {
     172                switch( attr ) {
     173                        case ast::EnumAttribute::Value: return "values_" + name ;
     174                        case ast::EnumAttribute::Label: return "labels_" + name;
     175                        default: /* Posn does not generate array */
     176                                return "";
     177                }
     178        }
     179
    171180}
    172181

  • src/AST/Decl.hpp

    rda87eaf r4e08a54  
    303303};
    304304
     305enum class EnumAttribute{ Value, Posn, Label };
    305306/// enum declaration `enum Foo { ... };`
    306307class EnumDecl final : public AggregateDecl {
    … …  
    326327        const char * typeString() const override { return aggrString( Enum ); }
    327328
    328 
     329        const std::string getUnmangeldArrayName( const EnumAttribute attr ) const;
    329330private:
    330331        EnumDecl * clone() const override { return new EnumDecl{ *this }; }

  • src/AST/Expr.cpp

    rda87eaf r4e08a54  
    246246ConstantExpr * ConstantExpr::from_bool( const CodeLocation & loc, bool b ) {
    247247        return new ConstantExpr{
    248                 loc, new BasicType{ BasicType::Bool }, b ? "1" : "0", (unsigned long long)b };
     248                loc, new BasicType{ BasicKind::Bool }, b ? "1" : "0", (unsigned long long)b };
    249249}
    250250
    251251ConstantExpr * ConstantExpr::from_int( const CodeLocation & loc, int i ) {
    252252        return new ConstantExpr{
    253                 loc, new BasicType{ BasicType::SignedInt }, std::to_string( i ), (unsigned long long)i };
     253                loc, new BasicType{ BasicKind::SignedInt }, std::to_string( i ), (unsigned long long)i };
    254254}
    255255
    256256ConstantExpr * ConstantExpr::from_ulong( const CodeLocation & loc, unsigned long i ) {
    257257        return new ConstantExpr{
    258                 loc, new BasicType{ BasicType::LongUnsignedInt }, std::to_string( i ),
     258                loc, new BasicType{ BasicKind::LongUnsignedInt }, std::to_string( i ),
    259259                (unsigned long long)i };
    260260}
    261261
    262262ConstantExpr * ConstantExpr::from_string( const CodeLocation & loc, const std::string & str ) {
    263         const Type * charType = new BasicType( BasicType::Char );
     263        const Type * charType = new BasicType( BasicKind::Char );
    264264        // Adjust the length of the string for the terminator.
    265265        const Expr * strSize = from_ulong( loc, str.size() + 1 );
    … …  
    277277
    278278SizeofExpr::SizeofExpr( const CodeLocation & loc, const Expr * e )
    279 : Expr( loc, new BasicType{ BasicType::LongUnsignedInt } ), expr( e ), type( nullptr ) {}
     279: Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), expr( e ), type( nullptr ) {}
    280280
    281281SizeofExpr::SizeofExpr( const CodeLocation & loc, const Type * t )
    282 : Expr( loc, new BasicType{ BasicType::LongUnsignedInt } ), expr( nullptr ), type( t ) {}
     282: Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), expr( nullptr ), type( t ) {}
    283283
    284284// --- AlignofExpr
    285285
    286286AlignofExpr::AlignofExpr( const CodeLocation & loc, const Expr * e )
    287 : Expr( loc, new BasicType{ BasicType::LongUnsignedInt } ), expr( e ), type( nullptr ) {}
     287: Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), expr( e ), type( nullptr ) {}
    288288
    289289AlignofExpr::AlignofExpr( const CodeLocation & loc, const Type * t )
    290 : Expr( loc, new BasicType{ BasicType::LongUnsignedInt } ), expr( nullptr ), type( t ) {}
     290: Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), expr( nullptr ), type( t ) {}
    291291
    292292// --- OffsetofExpr
    293293
    294294OffsetofExpr::OffsetofExpr( const CodeLocation & loc, const Type * ty, const DeclWithType * mem )
    295 : Expr( loc, new BasicType{ BasicType::LongUnsignedInt } ), type( ty ), member( mem ) {
     295: Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), type( ty ), member( mem ) {
    296296        assert( type );
    297297        assert( member );
    … …  
    302302OffsetPackExpr::OffsetPackExpr( const CodeLocation & loc, const StructInstType * ty )
    303303: Expr( loc, new ArrayType{
    304         new BasicType{ BasicType::LongUnsignedInt }, nullptr, FixedLen, DynamicDim }
     304        new BasicType{ BasicKind::LongUnsignedInt }, nullptr, FixedLen, DynamicDim }
    305305), type( ty ) {
    306306        assert( type );
    … …  
    311311LogicalExpr::LogicalExpr(
    312312        const CodeLocation & loc, const Expr * a1, const Expr * a2, LogicalFlag ia )
    313 : Expr( loc, new BasicType{ BasicType::SignedInt } ), arg1( a1 ), arg2( a2 ), isAnd( ia ) {}
     313: Expr( loc, new BasicType{ BasicKind::SignedInt } ), arg1( a1 ), arg2( a2 ), isAnd( ia ) {}
    314314
    315315// --- CommaExpr

  • src/AST/Fwd.hpp

    rda87eaf r4e08a54  
    133133class OneType;
    134134class GlobalScopeType;
    135 class EnumPosType;
     135class EnumAttrType;
    136136
    137137class Designation;

  • src/AST/Pass.hpp

    rda87eaf r4e08a54  
    222222        const ast::Type *             visit( const ast::UnionInstType        * ) override final;
    223223        const ast::Type *             visit( const ast::EnumInstType         * ) override final;
    224         const ast::Type *             visit( const ast::EnumPosType          * ) override final;
     224        const ast::Type *             visit( const ast::EnumAttrType         * ) override final;
    225225        const ast::Type *             visit( const ast::TraitInstType        * ) override final;
    226226        const ast::Type *             visit( const ast::TypeInstType         * ) override final;

  • src/AST/Pass.impl.hpp

    rda87eaf r4e08a54  
    477477                                CodeLocation{}, "__func__",
    478478                                new ast::ArrayType{
    479                                         new ast::BasicType{ ast::BasicType::Char, ast::CV::Const },
     479                                        new ast::BasicType{ ast::BasicKind::Char, ast::CV::Const },
    480480                                        nullptr, VariableLen, DynamicDim
    481481                                },
    … …  
    19401940
    19411941//--------------------------------------------------------------------------
    1942 // EnumPosType
    1943 template< typename core_t >
    1944 const ast::Type * ast::Pass< core_t >::visit( const ast::EnumPosType * node ) {
    1945         VISIT_START( node );
    1946 
     1942// EnumAttrType
     1943template< typename core_t >
     1944const ast::Type * ast::Pass< core_t >::visit( const ast::EnumAttrType * node ) {
     1945        VISIT_START( node );
    19471946        VISIT_END( Type, node );
    19481947}

  • src/AST/Print.cpp

    rda87eaf r4e08a54  
    15761576        }
    15771577
    1578         virtual const ast::Type * visit( const ast::EnumPosType * node ) override final {
    1579                 preprint( node );
    1580                 os << "enum pos with ";
     1578        virtual const ast::Type * visit( const ast::EnumAttrType * node ) override final {
     1579                preprint( node );
     1580                os << "enum attr ";
     1581        if ( node->attr == ast::EnumAttribute::Label ) {
     1582            os << "Label ";
     1583        } else if ( node->attr == ast::EnumAttribute::Value ) {
     1584            os << "Value ";
     1585        } else {
     1586            os << "Posn ";
     1587        }
    15811588                (*(node->instance)).accept( *this );
    15821589                return node;

  • src/AST/Type.hpp

    rda87eaf r4e08a54  
    2222#include <vector>
    2323
     24#include "BasicKind.hpp"     // for BasicKind
    2425#include "CVQualifiers.hpp"
    2526#include "Decl.hpp"          // for AggregateDecl subclasses
    … …  
    114115class BasicType final : public Type {
    115116public:
    116         // GENERATED START, DO NOT EDIT
    117         // GENERATED BY BasicTypes-gen.cc
    118         enum Kind {
    119                 Bool,
    120                 Char,
    121                 SignedChar,
    122                 UnsignedChar,
    123                 ShortSignedInt,
    124                 ShortUnsignedInt,
    125                 SignedInt,
    126                 UnsignedInt,
    127                 LongSignedInt,
    128                 LongUnsignedInt,
    129                 LongLongSignedInt,
    130                 LongLongUnsignedInt,
    131                 SignedInt128,
    132                 UnsignedInt128,
    133                 uFloat16,
    134                 uFloat16Complex,
    135                 uFloat32,
    136                 uFloat32Complex,
    137                 Float,
    138                 FloatComplex,
    139                 uFloat32x,
    140                 uFloat32xComplex,
    141                 uFloat64,
    142                 uFloat64Complex,
    143                 Double,
    144                 DoubleComplex,
    145                 uFloat64x,
    146                 uFloat64xComplex,
    147                 uuFloat80,
    148                 uFloat128,
    149                 uFloat128Complex,
    150                 uuFloat128,
    151                 LongDouble,
    152                 LongDoubleComplex,
    153                 uFloat128x,
    154                 uFloat128xComplex,
    155                 NUMBER_OF_BASIC_TYPES
    156         } kind;
    157         // GENERATED END
    158 
    159         /// xxx -- MAX_INTEGER_TYPE should probably be in BasicTypes-gen.cc, rather than hardcoded here
    160         enum { MAX_INTEGER_TYPE = UnsignedInt128 };
     117        BasicKind kind;
    161118
    162119        /// string names of basic types; generated to match with Kind
    163120        static const char *typeNames[];
    164121
    165         BasicType( Kind k, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
     122        BasicType( BasicKind k, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
    166123        : Type(q, std::move(as)), kind(k) {}
    167124
    168125        /// Check if this type represents an integer type
    169         bool isInteger() const { return (unsigned)kind <= (unsigned)MAX_INTEGER_TYPE; }
     126        bool isInteger() const { return kind <= MAX_INTEGER_TYPE; }
    170127
    171128        const Type * accept( Visitor & v ) const override { return v.visit( this ); }
    … …  
    362319using EnumInstType = SueInstType<EnumDecl>;
    363320
    364 class EnumPosType final : public Type {
     321class EnumAttrType final : public Type {
    365322public:
    366323        readonly<EnumInstType> instance;
    367         const Type * accept( Visitor & v ) const override { return v.visit( this ); }
    368         EnumPosType( const EnumInstType * instance ): instance(instance) {}
     324    EnumAttribute attr;
     325        const Type * accept( Visitor & v ) const override { return v.visit( this ); }
     326        EnumAttrType( const EnumInstType * instance, EnumAttribute attr = EnumAttribute::Posn )
     327                : instance(instance), attr(attr) {}
    369328       
    370 private:
    371         EnumPosType * clone() const override { return new EnumPosType{ *this }; }
     329    bool match( const ast::EnumAttrType * other) const {
     330        return instance->base->name == other->instance->base->name && attr == other->attr;
     331    }
     332private:
     333        EnumAttrType * clone() const override { return new EnumAttrType{ *this }; }
    372334        MUTATE_FRIEND
    373335};
    … …  
    425387        TypeInstType( const TypeInstType & o ) = default;
    426388
    427         TypeInstType( const TypeEnvKey & key );
     389        explicit TypeInstType( const TypeEnvKey & key );
    428390
    429391        /// sets `base`, updating `kind` correctly

  • src/AST/Visitor.hpp

    rda87eaf r4e08a54  
    119119    virtual const ast::Type *             visit( const ast::OneType              * ) = 0;
    120120    virtual const ast::Type *             visit( const ast::GlobalScopeType      * ) = 0;
    121     virtual const ast::Type *             visit( const ast::EnumPosType          * ) = 0;
     121    virtual const ast::Type *             visit( const ast::EnumAttrType         * ) = 0;
    122122    virtual const ast::Designation *      visit( const ast::Designation          * ) = 0;
    123123    virtual const ast::Init *             visit( const ast::SingleInit           * ) = 0;

  • src/AST/module.mk

    rda87eaf r4e08a54  
    1818        AST/Attribute.cpp \
    1919        AST/Attribute.hpp \
     20        AST/BasicKind.hpp \
    2021        AST/Bitfield.hpp \
    2122        AST/Chain.hpp \

  • src/BasicTypes-gen.cc

    rda87eaf r4e08a54  
    249249                } // for
    250250        } // for
     251        int lastInteger = NUMBER_OF_BASIC_TYPES;
    251252
    252253        for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) { // perform breath-first traversal to generate cost graph
    … …  
    259260                } // for
    260261        } // for
     262
     263        // Find the last integer type.
     264        // Assumes at least 1, and all come before the floating types.
     265        for ( int i = 1 ; i < NUMBER_OF_BASIC_TYPES ; i += 1 ) {
     266                if ( Floating == graph[i].sign ) {
     267                        lastInteger = (i - 1);
     268                        break;
     269                }
     270        }
    261271
    262272        #define STARTMK "// GENERATED START, DO NOT EDIT"
    … …  
    272282        size_t start, end;
    273283
    274         #define TypeH_AST TOP_SRCDIR "src/AST/Type.hpp"
     284        #define TypeH_AST TOP_SRCDIR "src/AST/BasicKind.hpp"
    275285        resetInput( file, TypeH_AST, buffer, code, str );
    276286
    … …  
    279289        code << str.substr( 0, start );
    280290
    281         code << "\t" << BYMK << endl;
    282         code << "\tenum Kind {" << endl;
     291        code << BYMK << endl;
     292        code << "enum BasicKind {" << endl;
    283293        for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) {
    284                 code << "\t\t" << graph[r].name << "," << endl;
    285         } // for
    286         code << "\t\tNUMBER_OF_BASIC_TYPES" << endl;
    287         code << "\t} kind;" << endl;
    288         code << "\t";                                                                           // indentation for end marker
     294                code << "\t" << graph[r].name << "," << endl;
     295        } // for
     296        code << "\tNUMBER_OF_BASIC_TYPES," << endl;
     297        code << "\tMAX_INTEGER_TYPE = " << graph[lastInteger].name << "," << endl;
     298        code << "};" << endl;
    289299
    290300        if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", TypeH_AST );
    … …  
    347357
    348358        code << "\t" << BYMK << endl;
    349         code << "\tstatic const int costMatrix[ast::BasicType::NUMBER_OF_BASIC_TYPES][ast::BasicType::NUMBER_OF_BASIC_TYPES] = { // path length from root to node" << endl
     359        code << "\tstatic const int costMatrix[ast::BasicKind::NUMBER_OF_BASIC_TYPES][ast::BasicKind::NUMBER_OF_BASIC_TYPES] = { // path length from root to node" << endl
    350360                 << "\t\t/*           ";
    351361        for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) { // titles
    … …  
    372382
    373383        code << "\t" << BYMK << endl;
    374         code << "\tstatic const int signMatrix[ast::BasicType::NUMBER_OF_BASIC_TYPES][ast::BasicType::NUMBER_OF_BASIC_TYPES] = { // number of sign changes in safe conversion" << endl
     384        code << "\tstatic const int signMatrix[ast::BasicKind::NUMBER_OF_BASIC_TYPES][ast::BasicKind::NUMBER_OF_BASIC_TYPES] = { // number of sign changes in safe conversion" << endl
    375385                 << "\t\t/*           ";
    376386        for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) { // titles
    … …  
    404414        enum { PER_ROW = 6 };
    405415        code << "\t" << BYMK << endl;
    406         code << "\t#define BT ast::BasicType::" << endl;
     416        code << "\t#define BT ast::BasicKind::" << endl;
    407417        code << "\tstatic const BT Kind commonTypes[BT NUMBER_OF_BASIC_TYPES][BT NUMBER_OF_BASIC_TYPES] = { // nearest common ancestor" << endl
    408418             << "\t\t/*\t\t ";
    … …  
    460470                "//   - \"Ds\" char16_t\n";
    461471
    462         code << "const std::string basicTypes[ast::BasicType::NUMBER_OF_BASIC_TYPES] = {" << endl;
     472        code << "const std::string basicTypes[ast::BasicKind::NUMBER_OF_BASIC_TYPES] = {" << endl;
    463473        for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) {
    464474                code << "\t\"" << graph[r].mangled << "\"," << setw(9 - strlen(graph[r].mangled)) << ' ' << "// " << graph[r].type << endl;

  • src/CodeGen/FixMain.cc

    rda87eaf r4e08a54  
    5252ast::ObjectDecl * makeIntObj(){
    5353        return new ast::ObjectDecl( CodeLocation(), "",
    54                 new ast::BasicType( ast::BasicType::SignedInt ) );
     54                new ast::BasicType( ast::BasicKind::SignedInt ) );
    5555}
    5656
    … …  
    5959                new ast::PointerType(
    6060                        new ast::PointerType(
    61                                 new ast::BasicType( ast::BasicType::Char ) ) ) );
     61                                new ast::BasicType( ast::BasicKind::Char ) ) ) );
    6262}
    6363

  • src/CodeGen/GenType.cc

    rda87eaf r4e08a54  
    4646        void postvisit( ast::UnionInstType const * type );
    4747        void postvisit( ast::EnumInstType const * type );
    48         void postvisit( ast::EnumPosType const * type );
     48        void postvisit( ast::EnumAttrType const * type );
    4949        void postvisit( ast::TypeInstType const * type );
    5050        void postvisit( ast::TupleType const * type );
    … …  
    8787
    8888void GenType::postvisit( ast::BasicType const * type ) {
    89         ast::BasicType::Kind kind = type->kind;
    90         assert( 0 <= kind && kind < ast::BasicType::NUMBER_OF_BASIC_TYPES );
     89        ast::BasicKind kind = type->kind;
     90        assert( 0 <= kind && kind < ast::BasicKind::NUMBER_OF_BASIC_TYPES );
    9191        result = std::string( ast::BasicType::typeNames[kind] ) + " " + result;
    9292        handleQualifiers( type );
    … …  
    240240}
    241241
    242 void GenType::postvisit( ast::EnumPosType const * type ) {
     242void GenType::postvisit( ast::EnumAttrType const * type ) {
    243243        postvisit( type->instance );
    244244}

  • src/Common/CodeLocationTools.cpp

    rda87eaf r4e08a54  
    188188    macro(UnionInstType, Type) \
    189189    macro(EnumInstType, Type) \
    190     macro(EnumPosType, Type) \
     190    macro(EnumAttrType, Type) \
    191191    macro(TraitInstType, Type) \
    192192    macro(TypeInstType, Type) \

  • src/Common/ResolvProtoDump.cpp

    rda87eaf r4e08a54  
    229229        void previsit( const ast::EnumInstType * ) {
    230230                // TODO: Add the meaningful text representation of typed enum
    231                 ss << (int)ast::BasicType::SignedInt;
     231                ss << (int)ast::BasicKind::SignedInt;
    232232        }
    233233
    … …  
    255255        // TODO: Support 0 and 1 with their type names and conversions.
    256256        void previsit( const ast::ZeroType * ) {
    257                 ss << (int)ast::BasicType::SignedInt;
     257                ss << (int)ast::BasicKind::SignedInt;
    258258        }
    259259
    260260        void previsit( const ast::OneType * ) {
    261                 ss << (int)ast::BasicType::SignedInt;
     261                ss << (int)ast::BasicKind::SignedInt;
    262262        }
    263263
    … …  
    366366        // TODO: Extra expression to resolve argument.
    367367        void previsit( const ast::SizeofExpr * ) {
    368                 ss << (int)ast::BasicType::LongUnsignedInt;
     368                ss << (int)ast::BasicKind::LongUnsignedInt;
    369369                visit_children = false;
    370370        }
    371371        void previsit( const ast::AlignofExpr * ) {
    372                 ss << (int)ast::BasicType::LongUnsignedInt;
     372                ss << (int)ast::BasicKind::LongUnsignedInt;
    373373                visit_children = false;
    374374        }
    375375        void previsit( const ast::UntypedOffsetofExpr * ) {
    376                 ss << (int)ast::BasicType::LongUnsignedInt;
     376                ss << (int)ast::BasicKind::LongUnsignedInt;
    377377                visit_children = false;
    378378        }
    … …  
    753753                // &? Address of operator.
    754754                out << "#$ptr<T> $addr T" << std::endl;
    755                 const int intId = (int)ast::BasicType::SignedInt;
     755                const int intId = (int)ast::BasicKind::SignedInt;
    756756                // ?&&? ?||? ?: Logical operators.
    757757                out << intId << " $and " << intId << ' ' << intId << std::endl;

  • src/Concurrency/Corun.cpp

    rda87eaf r4e08a54  
    130130                new ObjectDecl( loc,
    131131                    numProcsName,
    132                     new BasicType( BasicType::Kind::UnsignedInt ),
     132                    new BasicType( BasicKind::UnsignedInt ),
    133133                    new SingleInit( loc,
    134134                        new UntypedExpr( loc,
    … …  
    146146                new ObjectDecl( loc,
    147147                    currProcsName,
    148                     new BasicType( BasicType::Kind::UnsignedInt ),
     148                    new BasicType( BasicKind::UnsignedInt ),
    149149                    new SingleInit( loc, ConstantExpr::from_int( loc, 0 ) )
    150150                )

  • src/Concurrency/Waitfor.cpp

    rda87eaf r4e08a54  
    244244        ast::ObjectDecl * flag = new ast::ObjectDecl( location,
    245245                namer_flg.newName(),
    246                 new ast::BasicType( ast::BasicType::Bool ),
     246                new ast::BasicType( ast::BasicKind::Bool ),
    247247                new ast::SingleInit( location,
    248248                        ast::ConstantExpr::from_ulong( location, 0 )
    … …  
    349349        ast::ObjectDecl * timeout = new ast::ObjectDecl( topLocation,
    350350                namer_tim.newName(),
    351                 new ast::BasicType( ast::BasicType::LongLongUnsignedInt ),
     351                new ast::BasicType( ast::BasicKind::LongLongUnsignedInt ),
    352352                new ast::SingleInit( topLocation,
    353353                        ast::ConstantExpr::from_int( topLocation, -1 )
    … …  
    397397        ast::ObjectDecl * index = new ast::ObjectDecl( location,
    398398                namer_idx.newName(),
    399                 new ast::BasicType( ast::BasicType::ShortSignedInt ),
     399                new ast::BasicType( ast::BasicKind::ShortSignedInt ),
    400400                new ast::SingleInit( location,
    401401                        ast::ConstantExpr::from_int( location, -1 )

  • src/Concurrency/Waituntil.cpp

    rda87eaf r4e08a54  
    498498            rightExpr = genPredExpr( loc, currNode->right, idx, genLeaf );
    499499            return new LogicalExpr( loc,
    500                 new CastExpr( loc, leftExpr, new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast ),
    501                 new CastExpr( loc, rightExpr, new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast ),
     500                new CastExpr( loc, leftExpr, new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast ),
     501                new CastExpr( loc, rightExpr, new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast ),
    502502                LogicalFlag::AndExpr
    503503            );
    … …  
    507507            rightExpr = genPredExpr( loc, currNode->right, idx, genLeaf );
    508508            return new LogicalExpr( loc,
    509                 new CastExpr( loc, leftExpr, new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast ),
    510                 new CastExpr( loc, rightExpr, new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast ),
     509                new CastExpr( loc, leftExpr, new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast ),
     510                new CastExpr( loc, rightExpr, new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast ),
    511511                LogicalFlag::OrExpr );
    512512            break;
    … …  
    556556            new ObjectDecl( loc,
    557557                "clause_statuses",
    558                 new PointerType( new BasicType( BasicType::Kind::LongUnsignedInt ) )
     558                new PointerType( new BasicType( BasicKind::LongUnsignedInt ) )
    559559            )
    560560        },
    … …  
    562562            new ObjectDecl( loc,
    563563                "sat_ret",
    564                 new BasicType( BasicType::Kind::Bool )
     564                new BasicType( BasicKind::Bool )
    565565            )
    566566        },
    … …  
    766766                new ObjectDecl( loc,
    767767                    idxName,
    768                     new BasicType( BasicType::Kind::SignedInt ),
     768                    new BasicType( BasicKind::SignedInt ),
    769769                    new SingleInit( loc, ConstantExpr::from_int( loc, 0 ) )
    770770                )
    … …  
    893893                    new ObjectDecl( cLoc,
    894894                        currClause->whenName,
    895                         new BasicType( BasicType::Kind::Bool ),
     895                        new BasicType( BasicKind::Bool ),
    896896                        new SingleInit( cLoc, ast::deepCopy( stmt->clauses.at(i)->when_cond ) )
    897897                    )
    … …  
    915915                new ObjectDecl( stmt->else_cond->location,
    916916                    elseWhenName,
    917                     new BasicType( BasicType::Kind::Bool ),
     917                    new BasicType( BasicKind::Bool ),
    918918                    new SingleInit( stmt->else_cond->location, ast::deepCopy( stmt->else_cond ) )
    919919                )
    … …  
    945945                    new CastExpr( cLoc,
    946946                        new AddressExpr( cLoc, new NameExpr( cLoc, data.at(i)->nodeName ) ),
    947                         new BasicType( BasicType::Kind::LongUnsignedInt ), GeneratedFlag::ExplicitCast
     947                        new BasicType( BasicKind::LongUnsignedInt ), GeneratedFlag::ExplicitCast
    948948                    )
    949949                }
    … …  
    986986                    new CastExpr( cLoc,
    987987                        new NameExpr( cLoc, elseWhenName ),
    988                         new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast
     988                        new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast
    989989                    ),
    990990                    new CastExpr( cLoc,
    991991                        raceFnCall,
    992                         new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast
     992                        new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast
    993993                    ),
    994994                    LogicalFlag::AndExpr
    … …  
    10161016            new CastExpr( cLoc,
    10171017                new NameExpr( cLoc, data.at(idx)->whenName ),
    1018                 new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast
     1018                new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast
    10191019            ),
    10201020            new CastExpr( cLoc,
    10211021                baseCond,
    1022                 new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast
     1022                new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast
    10231023            ),
    10241024            LogicalFlag::AndExpr
    … …  
    10341034                        new NameExpr( cLoc, data.at(idx)->nodeName ),
    10351035                        new AddressExpr( cLoc, new NameExpr( cLoc, data.at(idx)->statusName ) ),
    1036                         ConstantExpr::null( cLoc, new PointerType( new BasicType( BasicType::Kind::SignedInt ) ) )
     1036                        ConstantExpr::null( cLoc, new PointerType( new BasicType( BasicKind::SignedInt ) ) )
    10371037                    }
    10381038                )
    … …  
    10961096        new ObjectDecl( loc,
    10971097            statusName,
    1098             new BasicType( BasicType::Kind::LongUnsignedInt ),
     1098            new BasicType( BasicKind::LongUnsignedInt ),
    10991099            new SingleInit( loc, ConstantExpr::from_int( loc, 0 ) )
    11001100        )
    … …  
    11141114            new NameExpr( cLoc, "?!=?" ),
    11151115            {
    1116                 ConstantExpr::null( cLoc, new PointerType( new BasicType( BasicType::Kind::LongUnsignedInt ) ) ),
     1116                ConstantExpr::null( cLoc, new PointerType( new BasicType( BasicKind::LongUnsignedInt ) ) ),
    11171117                new UntypedExpr( cLoc,
    11181118                    new NameExpr( cLoc, "__get_clause_status" ),
    … …  
    11281128                new CastExpr( cLoc,
    11291129                    new NameExpr( cLoc, clauseData.at(i)->whenName ),
    1130                     new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast
     1130                    new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast
    11311131                ),
    11321132                new CastExpr( cLoc,
    11331133                    statusPtrCheck,
    1134                     new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast
     1134                    new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast
    11351135                ),
    11361136                LogicalFlag::AndExpr
    … …  
    11621162                new CastExpr( loc,
    11631163                    new NameExpr( loc, clauseData.at( whenIndices.at(i) )->whenName ),
    1164                     new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast
     1164                    new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast
    11651165                ),
    11661166                new CastExpr( loc,
    11671167                    lastExpr,
    1168                     new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast
     1168                    new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast
    11691169                ),
    11701170                LogicalFlag::OrExpr
    … …  
    12201220        new ObjectDecl( loc,
    12211221            pCountName,
    1222             new BasicType( BasicType::Kind::SignedInt ),
     1222            new BasicType( BasicKind::SignedInt ),
    12231223            new SingleInit( loc, ConstantExpr::from_int( loc, 0 ) )
    12241224        )
    … …  
    12291229        new ObjectDecl( loc,
    12301230            statusArrName,
    1231             new ArrayType( new BasicType( BasicType::Kind::LongUnsignedInt ), ConstantExpr::from_int( loc, numClauses ), LengthFlag::FixedLen, DimensionFlag::DynamicDim ),
     1231            new ArrayType( new BasicType( BasicKind::LongUnsignedInt ), ConstantExpr::from_int( loc, numClauses ), LengthFlag::FixedLen, DimensionFlag::DynamicDim ),
    12321232            new ListInit( loc,
    12331233                {
    … …  
    13311331            new CastExpr( cLoc,
    13321332                statusExpr,
    1333                 new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast
     1333                new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast
    13341334            ),
    13351335            new CastExpr( cLoc,
    13361336                genSelectTraitCall( stmt->clauses.at(i), clauseData.at(i), "unregister_select" ),
    1337                 new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast
     1337                new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast
    13381338            ),
    13391339            LogicalFlag::AndExpr
    … …  
    13461346                new CastExpr( cLoc,
    13471347                    new NameExpr( cLoc, clauseData.at(i)->whenName ),
    1348                     new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast
     1348                    new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast
    13491349                ),
    13501350                new CastExpr( cLoc,
    13511351                    statusExpr,
    1352                     new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast
     1352                    new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast
    13531353                ),
    13541354                LogicalFlag::AndExpr

  • src/ControlStruct/ExceptDecl.cpp

    rda87eaf r4e08a54  
    9999                createExceptionInstType( exceptionName, params ) ) );
    100100        type->returns.push_back( new ast::PointerType(
    101                 new ast::BasicType( ast::BasicType::Char, ast::CV::Const ) ) );
     101                new ast::BasicType( ast::BasicKind::Char, ast::CV::Const ) ) );
    102102        return type;
    103103}
    … …  
    344344                                "",
    345345                                new ast::PointerType(
    346                                         new ast::BasicType( ast::BasicType::Char, ast::CV::Const ) )
     346                                        new ast::BasicType( ast::BasicKind::Char, ast::CV::Const ) )
    347347                        ),
    348348                },

  • src/ControlStruct/ExceptTranslate.cpp

    rda87eaf r4e08a54  
    182182                location,
    183183                "__handler_index",
    184                 new ast::BasicType( ast::BasicType::SignedInt )
     184                new ast::BasicType( ast::BasicKind::SignedInt )
    185185                );
    186186}
    … …  
    201201                location,
    202202                "__ret_bool",
    203                 new ast::BasicType( ast::BasicType::Bool ),
     203                new ast::BasicType( ast::BasicKind::Bool ),
    204204                nullptr, //init
    205205                ast::Storage::Classes{},
    … …  
    231231                location,
    232232                "__handler_index",
    233                 new ast::BasicType(ast::BasicType::SignedInt),
     233                new ast::BasicType( ast::BasicKind::SignedInt ),
    234234                nullptr,
    235235                ast::Storage::Classes{},

  • src/GenPoly/Box.cpp

    rda87eaf r4e08a54  
    4343/// The layout type is used to represent sizes, alignments and offsets.
    4444ast::BasicType * makeLayoutType() {
    45         return new ast::BasicType( ast::BasicType::LongUnsignedInt );
     45        return new ast::BasicType( ast::BasicKind::LongUnsignedInt );
    4646}
    4747
    4848/// Fixed version of layout type (just adding a 'C' in C++ style).
    4949ast::BasicType * makeLayoutCType() {
    50         return new ast::BasicType( ast::BasicType::LongUnsignedInt,
     50        return new ast::BasicType( ast::BasicKind::LongUnsignedInt,
    5151                ast::CV::Qualifiers( ast::CV::Const ) );
    5252}
    … …  
    16171617ast::Type * polyToMonoType( CodeLocation const & location,
    16181618                ast::Type const * declType ) {
    1619         auto charType = new ast::BasicType( ast::BasicType::Char );
     1619        auto charType = new ast::BasicType( ast::BasicKind::Char );
    16201620        auto size = new ast::NameExpr( location,
    16211621                sizeofName( Mangle::mangleType( declType ) ) );

  • src/GenPoly/Lvalue.cpp

    rda87eaf r4e08a54  
    133133                        return func->linkage == ast::Linkage::Intrinsic
    134134                                && lvalueFunctions.count( func->name );
    135                 }
    136         }
    137         return false;
    138 }
    139 
    140 bool isGeneratedInstrinct( ast::Expr const * expr ) {
    141         if ( auto app = dynamic_cast<ast::ApplicationExpr const *>( expr ) ) {
    142                 if ( app->args.size() == 2 && ast::getFunction( app )->name == "?[?]" ) {
    143                         auto param_1 = dynamic_cast<ast::VariableExpr const *>(app->args.front().get());
    144                         if ( param_1 ) {
    145                                 auto param_1_as_obj = param_1->var.as<ast::ObjectDecl>();
    146                                 return ( param_1_as_obj->name.find( "values_") != std::string::npos
    147                                         ||  param_1_as_obj->name.find( "labels_" ) != std::string::npos );
    148                         }
    149135                }
    150136        }
    … …  
    176162                ast::ApplicationExpr const * expr ) {
    177163
    178         if ( skip == SkipInProgress || !isIntrinsicReference( expr ) || isGeneratedInstrinct( expr ) ) {
     164        if ( skip == SkipInProgress || !isIntrinsicReference( expr ) ) {
    179165                return expr;
    180166        }

  • src/InitTweak/FixInit.cpp

    rda87eaf r4e08a54  
    847847
    848848                        // static bool __objName_uninitialized = true
    849                         auto boolType = new ast::BasicType( ast::BasicType::Kind::Bool );
     849                        auto boolType = new ast::BasicType( ast::BasicKind::Bool );
    850850                        auto boolInitExpr = new ast::SingleInit(loc, ast::ConstantExpr::from_int(loc, 1 ) );
    851851                        auto isUninitializedVar = new ast::ObjectDecl(loc, objDecl->mangleName + "_uninitialized", boolType, boolInitExpr, ast::Storage::Static, ast::Linkage::Cforall);

  • src/Makefile.am

    rda87eaf r4e08a54  
    5353include Virtual/module.mk
    5454
    55 $(addprefix $(srcdir)/, ResolvExpr/ConversionCost.cc ResolvExpr/CommonType.cc SymTab/ManglerCommon.cc) : $(srcdir)/AST/Type.hpp
     55$(addprefix $(srcdir)/, ResolvExpr/ConversionCost.cc ResolvExpr/CommonType.cc SymTab/ManglerCommon.cc) : $(srcdir)/AST/BasicKind.hpp
    5656
    57 $(srcdir)/AST/Type.hpp : BasicTypes-gen.cc
     57$(srcdir)/AST/BasicKind.hpp : BasicTypes-gen.cc
    5858        ${AM_V_GEN}${CXXCOMPILE} $< -o BasicTypes-gen -Wall -Wextra -Werror=return-type
    5959        @./BasicTypes-gen

  • src/Parser/ExpressionNode.cc

    rda87eaf r4e08a54  
    2323#include <string>                  // for string, operator+, operator==
    2424
     25#include "AST/BasicKind.hpp"       // for BasicKind
    2526#include "AST/Expr.hpp"            // for NameExpr
    26 #include "AST/Type.hpp"            // for BaseType, SueInstType
     27#include "AST/Type.hpp"            // for Type, LengthFlag, DimentionFlag
    2728#include "Common/SemanticError.h"  // for SemanticError
    2829#include "Common/utility.h"        // for maybeMoveBuild, maybeBuild, CodeLo...
    … …  
    126127ast::Expr * build_constantInteger(
    127128                const CodeLocation & location, string & str ) {
    128         static const ast::BasicType::Kind kind[2][6] = {
     129        static const ast::BasicKind kind[2][6] = {
    129130                // short (h) must be before char (hh) because shorter type has the longer suffix
    130                 { ast::BasicType::ShortSignedInt, ast::BasicType::SignedChar, ast::BasicType::SignedInt, ast::BasicType::LongSignedInt, ast::BasicType::LongLongSignedInt, /* BasicType::SignedInt128 */ ast::BasicType::LongLongSignedInt, },
    131                 { ast::BasicType::ShortUnsignedInt, ast::BasicType::UnsignedChar, ast::BasicType::UnsignedInt, ast::BasicType::LongUnsignedInt, ast::BasicType::LongLongUnsignedInt, /* BasicType::UnsignedInt128 */ ast::BasicType::LongLongUnsignedInt, },
     131                { ast::BasicKind::ShortSignedInt, ast::BasicKind::SignedChar, ast::BasicKind::SignedInt, ast::BasicKind::LongSignedInt, ast::BasicKind::LongLongSignedInt, /* BasicKind::SignedInt128 */ ast::BasicKind::LongLongSignedInt, },
     132                { ast::BasicKind::ShortUnsignedInt, ast::BasicKind::UnsignedChar, ast::BasicKind::UnsignedInt, ast::BasicKind::LongUnsignedInt, ast::BasicKind::LongLongUnsignedInt, /* BasicKind::UnsignedInt128 */ ast::BasicKind::LongLongUnsignedInt, },
    132133        };
    133134
    … …  
    313314                if ( ltype == 6 ) {                                                             // int128, (int128)constant
    314315                        ret2 = new ast::ConstantExpr( location,
    315                                 new ast::BasicType( ast::BasicType::LongLongSignedInt ),
     316                                new ast::BasicType( ast::BasicKind::LongLongSignedInt ),
    316317                                str2,
    317318                                v2 );
    … …  
    379380ast::Expr * build_constantFloat(
    380381                const CodeLocation & location, string & str ) {
    381         static const ast::BasicType::Kind kind[2][12] = {
    382                 { ast::BasicType::Float, ast::BasicType::Double, ast::BasicType::LongDouble, ast::BasicType::uuFloat80, ast::BasicType::uuFloat128, ast::BasicType::uFloat16, ast::BasicType::uFloat32, ast::BasicType::uFloat32x, ast::BasicType::uFloat64, ast::BasicType::uFloat64x, ast::BasicType::uFloat128, ast::BasicType::uFloat128x },
    383                 { ast::BasicType::FloatComplex, ast::BasicType::DoubleComplex, ast::BasicType::LongDoubleComplex, ast::BasicType::NUMBER_OF_BASIC_TYPES, ast::BasicType::NUMBER_OF_BASIC_TYPES, ast::BasicType::uFloat16Complex, ast::BasicType::uFloat32Complex, ast::BasicType::uFloat32xComplex, ast::BasicType::uFloat64Complex, ast::BasicType::uFloat64xComplex, ast::BasicType::uFloat128Complex, ast::BasicType::uFloat128xComplex },
     382        static const ast::BasicKind kind[2][12] = {
     383                { ast::BasicKind::Float, ast::BasicKind::Double, ast::BasicKind::LongDouble, ast::BasicKind::uuFloat80, ast::BasicKind::uuFloat128, ast::BasicKind::uFloat16, ast::BasicKind::uFloat32, ast::BasicKind::uFloat32x, ast::BasicKind::uFloat64, ast::BasicKind::uFloat64x, ast::BasicKind::uFloat128, ast::BasicKind::uFloat128x },
     384                { ast::BasicKind::FloatComplex, ast::BasicKind::DoubleComplex, ast::BasicKind::LongDoubleComplex, ast::BasicKind::NUMBER_OF_BASIC_TYPES, ast::BasicKind::NUMBER_OF_BASIC_TYPES, ast::BasicKind::uFloat16Complex, ast::BasicKind::uFloat32Complex, ast::BasicKind::uFloat32xComplex, ast::BasicKind::uFloat64Complex, ast::BasicKind::uFloat64xComplex, ast::BasicKind::uFloat128Complex, ast::BasicKind::uFloat128xComplex },
    384385        };
    385386
    … …  
    447448
    448449        ast::Expr * ret = new ast::ConstantExpr( location,
    449                 new ast::BasicType( ast::BasicType::Char ),
     450                new ast::BasicType( ast::BasicKind::Char ),
    450451                str,
    451452                (unsigned long long int)(unsigned char)str[1] );
    … …  
    482483        Default:                                                                                        // char default string type
    483484        default:
    484                 strtype = new ast::BasicType( ast::BasicType::Char );
     485                strtype = new ast::BasicType( ast::BasicKind::Char );
    485486        } // switch
    486487        ast::ArrayType * at = new ast::ArrayType(
    … …  
    664665                member->name
    665666        );
    666         ret->result = new ast::BasicType( ast::BasicType::LongUnsignedInt );
     667        ret->result = new ast::BasicType( ast::BasicKind::LongUnsignedInt );
    667668        delete member;
    668669        return ret;

  • src/Parser/TypeData.cc

    rda87eaf r4e08a54  
    1919#include <ostream>                 // for operator<<, ostream, basic_ostream
    2020
     21#include "AST/Attribute.hpp"       // for Attribute
    2122#include "AST/Decl.hpp"            // for AggregateDecl, ObjectDecl, TypeDe...
    22 #include "AST/Attribute.hpp"       // for Attribute
    2323#include "AST/Init.hpp"            // for SingleInit, ListInit
    2424#include "AST/Print.hpp"           // for print
     25#include "AST/Type.hpp"            // for Type
    2526#include "Common/SemanticError.h"  // for SemanticError
    2627#include "Common/utility.h"        // for splice, spliceBegin
    … …  
    10101011                // fill in implicit int
    10111012                return new ast::BasicType(
    1012                         ast::BasicType::SignedInt,
     1013                        ast::BasicKind::SignedInt,
    10131014                        buildQualifiers( td )
    10141015                );
    … …  
    10951096
    10961097ast::Type * buildBasicType( const TypeData * td ) {
    1097         ast::BasicType::Kind ret;
     1098        ast::BasicKind ret;
    10981099
    10991100        switch ( td->basictype ) {
    … …  
    11161117                } // if
    11171118
    1118                 ret = ast::BasicType::Bool;
     1119                ret = ast::BasicKind::Bool;
    11191120                break;
    11201121
    … …  
    11231124                // character types. The implementation shall define char to have the same range, representation, and behavior as
    11241125                // either signed char or unsigned char.
    1125                 static ast::BasicType::Kind chartype[] = { ast::BasicType::SignedChar, ast::BasicType::UnsignedChar, ast::BasicType::Char };
     1126                static ast::BasicKind chartype[] = { ast::BasicKind::SignedChar, ast::BasicKind::UnsignedChar, ast::BasicKind::Char };
    11261127
    11271128                if ( td->length != TypeData::NoLength ) {
    … …  
    11331134
    11341135        case TypeData::Int:
    1135                 static ast::BasicType::Kind inttype[2][4] = {
    1136                         { ast::BasicType::ShortSignedInt, ast::BasicType::LongSignedInt, ast::BasicType::LongLongSignedInt, ast::BasicType::SignedInt },
    1137                         { ast::BasicType::ShortUnsignedInt, ast::BasicType::LongUnsignedInt, ast::BasicType::LongLongUnsignedInt, ast::BasicType::UnsignedInt },
     1136                static ast::BasicKind inttype[2][4] = {
     1137                        { ast::BasicKind::ShortSignedInt, ast::BasicKind::LongSignedInt, ast::BasicKind::LongLongSignedInt, ast::BasicKind::SignedInt },
     1138                        { ast::BasicKind::ShortUnsignedInt, ast::BasicKind::LongUnsignedInt, ast::BasicKind::LongLongUnsignedInt, ast::BasicKind::UnsignedInt },
    11381139                };
    11391140
    … …  
    11461147
    11471148        case TypeData::Int128:
    1148                 ret = td->signedness == TypeData::Unsigned ? ast::BasicType::UnsignedInt128 : ast::BasicType::SignedInt128;
     1149                ret = td->signedness == TypeData::Unsigned ? ast::BasicKind::UnsignedInt128 : ast::BasicKind::SignedInt128;
    11491150                if ( td->length != TypeData::NoLength ) {
    11501151                        genTSError( TypeData::lengthNames[ td->length ], td->basictype );
    … …  
    11641165        case TypeData::uFloat128:
    11651166        case TypeData::uFloat128x:
    1166                 static ast::BasicType::Kind floattype[2][12] = {
    1167                         { ast::BasicType::FloatComplex, ast::BasicType::DoubleComplex, ast::BasicType::LongDoubleComplex, (ast::BasicType::Kind)-1, (ast::BasicType::Kind)-1, ast::BasicType::uFloat16Complex, ast::BasicType::uFloat32Complex, ast::BasicType::uFloat32xComplex, ast::BasicType::uFloat64Complex, ast::BasicType::uFloat64xComplex, ast::BasicType::uFloat128Complex, ast::BasicType::uFloat128xComplex, },
    1168                         { ast::BasicType::Float, ast::BasicType::Double, ast::BasicType::LongDouble, ast::BasicType::uuFloat80, ast::BasicType::uuFloat128, ast::BasicType::uFloat16, ast::BasicType::uFloat32, ast::BasicType::uFloat32x, ast::BasicType::uFloat64, ast::BasicType::uFloat64x, ast::BasicType::uFloat128, ast::BasicType::uFloat128x, },
     1167                static ast::BasicKind floattype[2][12] = {
     1168                        { ast::BasicKind::FloatComplex, ast::BasicKind::DoubleComplex, ast::BasicKind::LongDoubleComplex, (ast::BasicKind)-1, (ast::BasicKind)-1, ast::BasicKind::uFloat16Complex, ast::BasicKind::uFloat32Complex, ast::BasicKind::uFloat32xComplex, ast::BasicKind::uFloat64Complex, ast::BasicKind::uFloat64xComplex, ast::BasicKind::uFloat128Complex, ast::BasicKind::uFloat128xComplex, },
     1169                        { ast::BasicKind::Float, ast::BasicKind::Double, ast::BasicKind::LongDouble, ast::BasicKind::uuFloat80, ast::BasicKind::uuFloat128, ast::BasicKind::uFloat16, ast::BasicKind::uFloat32, ast::BasicKind::uFloat32x, ast::BasicKind::uFloat64, ast::BasicKind::uFloat64x, ast::BasicKind::uFloat128, ast::BasicKind::uFloat128x, },
    11691170                };
    11701171
    … …  
    12131214
    12141215static ast::Type * buildDefaultType( const TypeData * td ) {
    1215         return ( td ) ? typebuild( td ) : new ast::BasicType( ast::BasicType::SignedInt );
     1216        return ( td ) ? typebuild( td ) : new ast::BasicType( ast::BasicKind::SignedInt );
    12161217} // buildDefaultType
    12171218
    … …  
    15791580                        td->location,
    15801581                        "",
    1581                         new ast::BasicType( ast::BasicType::SignedInt ),
     1582                        new ast::BasicType( ast::BasicKind::SignedInt ),
    15821583                        (ast::Init *)nullptr,
    15831584                        ast::Storage::Classes(),
    … …  
    16671668        } else {
    16681669                ft->returns.push_back(
    1669                         new ast::BasicType( ast::BasicType::SignedInt ) );
     1670                        new ast::BasicType( ast::BasicKind::SignedInt ) );
    16701671        } // if
    16711672        return ft;

  • src/Parser/TypeData.h

    rda87eaf r4e08a54  
    2020#include <string>                                   // for string
    2121
    22 #include "AST/Type.hpp"                             // for Type
     22#include "AST/CVQualifiers.hpp"                     // for CV
     23#include "AST/Fwd.hpp"                              // for Type
    2324#include "DeclarationNode.h"                        // for DeclarationNode
    2425

  • src/Parser/parser.yy

    rda87eaf r4e08a54  
    5555#include "TypedefTable.h"
    5656#include "TypeData.h"
     57#include "AST/Type.hpp"                                 // for BasicType, BasicKind
    5758#include "Common/SemanticError.h"                                               // error_str
    5859#include "Common/utility.h"                                                             // for maybeMoveBuild, maybeBuild, CodeLo...
    … …  
    260261        ast::ConstantExpr * constant = dynamic_cast<ast::ConstantExpr *>(type->expr.get());
    261262        if ( constant && (constant->rep == "0" || constant->rep == "1") ) {
    262                 type = new ExpressionNode( new ast::CastExpr( location, maybeMoveBuild(type), new ast::BasicType( ast::BasicType::SignedInt ) ) );
     263                type = new ExpressionNode( new ast::CastExpr( location, maybeMoveBuild(type), new ast::BasicType( ast::BasicKind::SignedInt ) ) );
    263264        } // if
    264265        DeclarationNode * initDecl = distAttr(

  • src/ResolvExpr/CandidateFinder.cpp

    rda87eaf r4e08a54  
    284284                const CodeLocation & location,
    285285                const ast::Type * paramType, const ast::Init * init, const ExplodedArgs & args,
    286                 std::vector< ArgPack > & results, std::size_t & genStart, const ast::SymbolTable & symtab,
     286                std::vector< ArgPack > & results, std::size_t & genStart, const ResolveContext & context,
    287287                unsigned nTuples = 0
    288288        ) {
    … …  
    294294                                // ^^^ need to handle the case where a tuple has a default argument
    295295                                if ( ! instantiateArgument( location,
    296                                         type, nullptr, args, results, genStart, symtab, nTuples ) ) return false;
     296                                        type, nullptr, args, results, genStart, context, nTuples ) ) return false;
    297297                                nTuples = 0;
    298298                        }
    … …  
    509509
    510510                                // attempt to unify types
    511                                 if ( unify( paramType, argType, env, need, have, open ) ) {
     511                                ast::ptr<ast::Type> common;
     512                                if ( unify( paramType, argType, env, need, have, open, common ) ) {
    512513                                        // add new result
    513                                         results.emplace_back(
    514                                                 i, expr, std::move( env ), std::move( need ), std::move( have ), std::move( open ),
    515                                                 nextArg + 1, nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
     514                                        assert( common );
     515                                                results.emplace_back(
     516                                                        i, expr, std::move( env ), std::move( need ), std::move( have ), std::move( open ),
     517                                                        nextArg + 1, nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
     518                                        //}
    516519                                }
    517520                        }
    … …  
    785788                                        auto obj = funcDecl->params[i].strict_as<ast::ObjectDecl>();
    786789                                        if ( !instantiateArgument( location,
    787                                                 funcType->params[i], obj->init, args, results, genStart, symtab)) return;
     790                                                funcType->params[i], obj->init, args, results, genStart, context)) return;
    788791                                }
    789792                                goto endMatch;
    … …  
    795798                        // no default args for indirect calls
    796799                        if ( !instantiateArgument( location,
    797                                 param, nullptr, args, results, genStart, symtab ) ) return;
     800                                param, nullptr, args, results, genStart, context ) ) return;
    798801                }
    799802
    … …  
    890893                } else if ( auto unionInst = aggrExpr->result.as< ast::UnionInstType >() ) {
    891894                        addAggMembers( unionInst, aggrExpr, *cand, Cost::unsafe, "" );
    892                 }
    893                 else if ( auto enumInst = aggrExpr->result.as< ast::EnumInstType >() ) {
    894                         if (enumInst->base && enumInst->base->base) {
    895             const CodeLocation &location = cand->expr->location;
    896 
    897             CandidateFinder funcFinder(context, tenv);
    898             auto nameExpr = new ast::NameExpr(location, "valueE");
    899             ResolveMode mode = {true, false, selfFinder.candidates.empty()};
    900             funcFinder.find( nameExpr, mode );
    901 
    902             // make variableExpr itself the candidate for the value Call
    903             ExplodedArgs argExpansions;
    904             argExpansions.emplace_back();
    905             auto &argE = argExpansions.back();
    906 
    907             argE.emplace_back(*cand, symtab); // Use the typed name expr as param for value
    908 
    909             CandidateList found;
    910             SemanticErrorException errors;
    911 
    912             for (CandidateRef &func : funcFinder) {
    913                 try {
    914                     const ast::Type *funcResult =
    915                         func->expr->result->stripReferences();
    916                     if (auto pointer = dynamic_cast<const ast::PointerType *>(
    917                             funcResult)) {
    918                         if (auto function =
    919                                 pointer->base.as<ast::FunctionType>()) {
    920                             CandidateRef newFunc{new Candidate{*func}};
    921                             newFunc->expr = referenceToRvalueConversion(
    922                                 newFunc->expr, newFunc->cost);
    923                             makeFunctionCandidates( location,
    924                                                    newFunc, function,
    925                                                    argExpansions, found );
    926                         }
    927                     }
    928                 } catch (SemanticErrorException &e) {
    929                     std::cerr
    930                         << "Resolving value function should cause an error"
    931                         << std::endl;
    932                     errors.append(e);
    933                 }
    934             }
    935 
    936             if (found.empty()) {
    937                 std::cerr << "Resolve value function should always success"
    938                           << std::endl;
    939             }
    940 
    941             for (CandidateRef &withFunc : found) {
    942                 withFunc->cost.incSafe();
    943                 Cost cvtCost =
    944                     computeApplicationConversionCost(withFunc, symtab);
    945                 assert(cvtCost != Cost::infinity);
    946 
    947                 candidates.emplace_back(std::move(withFunc));
    948             }
    949         }
     895                } else if ( auto enumInst = aggrExpr->result.as< ast::EnumInstType >() ) {
     896                        if ( enumInst->base->base ) {
     897                                CandidateFinder finder( context, tenv );
     898                                auto location = aggrExpr->location;
     899                                auto callExpr = new ast::UntypedExpr(
     900                                        location, new ast::NameExpr( location, "valueE" ), {aggrExpr}
     901                                );
     902                                finder.find( callExpr );
     903                                CandidateList winners = findMinCost( finder.candidates );
     904                                if (winners.size() != 1) {
     905                                        SemanticError( callExpr, "Ambiguous expression in valueE..." );
     906                                }
     907                                CandidateRef & choice = winners.front();
     908                                choice->cost.incVar();
     909                                candidates.emplace_back( std::move(choice) );
     910                        }
     911
    950912                }
    951913        }
    … …  
    14141376                        ast::Expr * newExpr = data.combine( nameExpr->location, cost );
    14151377
     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
    14161385                        CandidateRef newCand = std::make_shared<Candidate>(
    1417                                 newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, Cost::zero,
     1386                                newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, bentConversion? Cost::safe: Cost::zero,
    14181387                                cost );
    14191388
    … …  
    14481417        auto cand = new Candidate(variableExpr, tenv);
    14491418        candidates.emplace_back(cand);
    1450 
    1451         if (auto enumInst = dynamic_cast<const ast::EnumInstType *>(
    1452                 variableExpr->var->get_type())) {
    1453             if (enumInst->base && enumInst->base->base) {
    1454                 const CodeLocation &location = cand->expr->location;
    1455 
    1456                 CandidateFinder funcFinder(context, tenv);
    1457                 auto nameExpr = new ast::NameExpr(location, "valueE");
    1458                 ResolveMode mode = {true, false, selfFinder.candidates.empty()};
    1459                 funcFinder.find( nameExpr, mode );
    1460 
    1461                 // make variableExpr itself the candidate for the value Call
    1462                 ExplodedArgs argExpansions;
    1463                 argExpansions.emplace_back();
    1464                 auto &argE = argExpansions.back();
    1465 
    1466                 argE.emplace_back(*cand, symtab);
    1467 
    1468                 CandidateList found;
    1469                 SemanticErrorException errors;
    1470 
    1471                 for (CandidateRef &func : funcFinder) {
    1472                     try {
    1473                     const ast::Type *funcResult =
    1474                         func->expr->result->stripReferences();
    1475                     if (auto pointer = dynamic_cast<const ast::PointerType *>(
    1476                             funcResult)) {
    1477                         if (auto function =
    1478                                 pointer->base.as<ast::FunctionType>()) {
    1479                             CandidateRef newFunc{new Candidate{*func}};
    1480                             newFunc->expr = referenceToRvalueConversion(
    1481                                 newFunc->expr, newFunc->cost);
    1482                             makeFunctionCandidates(variableExpr->location,
    1483                                                    newFunc, function,
    1484                                                    argExpansions, found);
    1485                         }
    1486                     }
    1487                     } catch (SemanticErrorException &e) {
    1488                         std::cerr
    1489                             << "Resolving value function should cause an error"
    1490                             << std::endl;
    1491                         errors.append(e);
    1492                     }
    1493                 }
    1494 
    1495                 if (found.empty()) {
    1496                     std::cerr << "Resolve value function should always success"
    1497                             << std::endl;
    1498                 }
    1499 
    1500                 for (CandidateRef &withFunc : found) {
    1501                     withFunc->cost.incSafe();
    1502                     Cost cvtCost =
    1503                         computeApplicationConversionCost(withFunc, symtab);
    1504                     assert(cvtCost != Cost::infinity);
    1505 
    1506                     candidates.emplace_back(std::move(withFunc));
    1507                 }
    1508             }
    1509         }
    15101419    }
    15111420
    … …  
    18391748
    18401749                                // unification run for side-effects
    1841                                 bool canUnify = unify( toType, cand->expr->result, env, need, have, open );
     1750                                ast::ptr<ast::Type> common;
     1751                                bool canUnify = unify( toType, cand->expr->result, env, need, have, open, common );
    18421752                                (void) canUnify;
    18431753                                Cost thisCost = computeConversionCost( cand->expr->result, toType, cand->expr->get_lvalue(),
    … …  
    18641774                                        // ambiguous case, still output candidates to print in error message
    18651775                                        if ( cand->cost == minExprCost && thisCost == minCastCost ) {
    1866                                                 CandidateRef newCand = std::make_shared<Candidate>(
    1867                                                         new ast::InitExpr{
    1868                                                                 initExpr->location,
    1869                                                                 restructureCast( cand->expr, toType ),
    1870                                                                 initAlt.designation },
    1871                                                         std::move(env), std::move( open ), std::move( need ), cand->cost + thisCost );
    1872                                                 // currently assertions are always resolved immediately so this should have no effect.
    1873                                                 // if this somehow changes in the future (e.g. delayed by indeterminate return type)
    1874                                                 // we may need to revisit the logic.
    1875                                                 inferParameters( newCand, matches );
     1776                                                auto commonAsEnumAttr = common.as<ast::EnumAttrType>();
     1777                                                if ( commonAsEnumAttr && commonAsEnumAttr->attr == ast::EnumAttribute::Value ) {
     1778                                                        auto callExpr = new ast::UntypedExpr(
     1779                                                                cand->expr->location, new ast::NameExpr( cand->expr->location, "valueE"), {cand->expr} );
     1780                                                        CandidateFinder finder( context, env );
     1781                                                        finder.find( callExpr );
     1782                                                        CandidateList winners = findMinCost( finder.candidates );
     1783                                                        if (winners.size() != 1) {
     1784                                                                SemanticError( callExpr, "Ambiguous expression in valueE..." );
     1785                                                        }
     1786                                                        CandidateRef & choice = winners.front();
     1787                                                        // assert( valueCall->result );
     1788                                                        CandidateRef newCand = std::make_shared<Candidate>(
     1789                                                                new ast::InitExpr{
     1790                                                                        initExpr->location,
     1791                                                                        // restructureCast( cand->expr, toType ),
     1792                                                                        choice->expr,
     1793                                                                        initAlt.designation },
     1794                                                                std::move(env), std::move( open ), std::move( need ), cand->cost + thisCost );
     1795                                                                inferParameters( newCand, matches );
     1796                                                } else {
     1797                                                        CandidateRef newCand = std::make_shared<Candidate>(
     1798                                                                new ast::InitExpr{
     1799                                                                        initExpr->location,
     1800                                                                        restructureCast( cand->expr, toType ),
     1801                                                                        initAlt.designation },
     1802                                                                std::move(env), std::move( open ), std::move( need ), cand->cost + thisCost );
     1803                                                        // currently assertions are always resolved immediately so this should have no effect.
     1804                                                        // if this somehow changes in the future (e.g. delayed by indeterminate return type)
     1805                                                        // we may need to revisit the logic.
     1806                                                        inferParameters( newCand, matches );
     1807                                                }
    18761808                                        }
    18771809                                }
    … …  
    19001832                                                std::make_shared<Candidate>(
    19011833                                                        newExpr, copy( tenv ), ast::OpenVarSet{},
    1902                                                         ast::AssertionSet{}, Cost::zero, cost
     1834                                                        ast::AssertionSet{}, Cost::safe, cost
    19031835                                                );
    19041836
    … …  
    22002132}
    22012133
     2134// get the valueE(...) ApplicationExpr that returns the enum value
     2135const ast::Expr * getValueEnumCall(
     2136        const ast::Expr * expr,
     2137        const ResolvExpr::ResolveContext & context, const ast::TypeEnvironment & env ) {
     2138                auto callExpr = new ast::UntypedExpr(
     2139                        expr->location, new ast::NameExpr( expr->location, "valueE"), {expr} );
     2140                CandidateFinder finder( context, env );
     2141                finder.find( callExpr );
     2142                CandidateList winners = findMinCost( finder.candidates );
     2143                if (winners.size() != 1) {
     2144                        SemanticError( callExpr, "Ambiguous expression in valueE..." );
     2145                }
     2146                CandidateRef & choice = winners.front();
     2147                return choice->expr;
     2148}
     2149
    22022150const ast::Expr * createCondExpr( const ast::Expr * expr ) {
    22032151        assert( expr );
    … …  
    22122160                        }
    22132161                ),
    2214                 new ast::BasicType( ast::BasicType::SignedInt )
     2162                new ast::BasicType( ast::BasicKind::SignedInt )
    22152163        );
    22162164}

  • src/ResolvExpr/CandidateFinder.hpp

    rda87eaf r4e08a54  
    3030struct CandidateFinder {
    3131        CandidateList candidates;          ///< List of candidate resolutions
    32         const ResolveContext & context;  ///< Information about where the canditates are being found.
     32        const ResolveContext & context;    ///< Information about where the canditates are being found.
    3333        const ast::TypeEnvironment & env;  ///< Substitutions performed in this resolution
    3434        ast::ptr< ast::Type > targetType;  ///< Target type for resolution
    3535        bool strictMode = false;           ///< If set to true, requires targetType to be exact match (inside return cast)
    3636        bool allowVoid = false;            ///< If set to true, allow void-returning function calls (only top level, cast to void and first in comma)
    37         std::set< std::string > otypeKeys;  /// different type may map to same key
     37        std::set< std::string > otypeKeys; ///< different type may map to same key
    3838
    3939        CandidateFinder(
    … …  
    7070        const ast::Expr * expr, Cost & cost );
    7171
     72/// Get the valueE application that returns the enum's value.
     73const ast::Expr * getValueEnumCall( const ast::Expr * expr,
     74        const ResolveContext & context, const ast::TypeEnvironment & env );
     75
    7276/// Wrap an expression to convert the result to a conditional result.
    7377const ast::Expr * createCondExpr( const ast::Expr * expr );

  • src/ResolvExpr/CommonType.cc

    rda87eaf r4e08a54  
    3838        // GENERATED START, DO NOT EDIT
    3939        // GENERATED BY BasicTypes-gen.cc
    40         #define BT ast::BasicType::
    41         static const BT Kind commonTypes[BT NUMBER_OF_BASIC_TYPES][BT NUMBER_OF_BASIC_TYPES] = { // nearest common ancestor
     40        #define BT ast::BasicKind::
     41        static const ast::BasicKind commonTypes[BT NUMBER_OF_BASIC_TYPES][BT NUMBER_OF_BASIC_TYPES] = { // nearest common ancestor
    4242                /*                                      B                       C                      SC                      UC                      SI                     SUI
    4343                                                        I                      UI                      LI                     LUI                     LLI                    LLUI
    … …  
    339339        // GENERATED END
    340340        static_assert(
    341                 sizeof(commonTypes)/sizeof(commonTypes[0][0]) == ast::BasicType::NUMBER_OF_BASIC_TYPES * ast::BasicType::NUMBER_OF_BASIC_TYPES,
     341                sizeof(commonTypes)/sizeof(commonTypes[0][0]) == ast::BasicKind::NUMBER_OF_BASIC_TYPES * ast::BasicKind::NUMBER_OF_BASIC_TYPES,
    342342                "Each basic type kind should have a corresponding row in the combined type matrix"
    343343        );
    … …  
    366366        void postvisit( const ast::BasicType * basic ) {
    367367                if ( auto basic2 = dynamic_cast< const ast::BasicType * >( type2 ) ) {
    368                         ast::BasicType::Kind kind;
     368                        ast::BasicKind kind;
    369369                        if (basic->kind != basic2->kind && !widen.first && !widen.second) return;
    370370                        else if (!widen.first) kind = basic->kind; // widen.second
    … …  
    385385                } else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( type2 ) ) {
    386386                        const ast::EnumDecl* enumDecl = enumInst->base;
    387                         if ( enumDecl->base ) {
    388                                 result = enumDecl->base.get();
    389                         } else {
    390                                 ast::BasicType::Kind kind = commonTypes[ basic->kind ][ ast::BasicType::SignedInt ];
     387                        if ( !enumDecl->base ) {
     388                                ast::BasicKind kind = commonTypes[ basic->kind ][ ast::BasicKind::SignedInt ];
    391389                                if (
    392390                                        ( ( kind == basic->kind && basic->qualifiers >= type2->qualifiers )
    … …  
    398396                                }
    399397                        }
    400                 } else if ( dynamic_cast< const ast::EnumPosType * >( type2 ) ) {
    401                         ast::BasicType::Kind kind = commonTypes[ basic->kind ][ ast::BasicType::SignedInt ];
    402                         if (
    403                                 ( ( kind == basic->kind && basic->qualifiers >= type2->qualifiers )
    404                                         || widen.first )
    405                                 && ( ( kind != basic->kind && basic->qualifiers <= type2->qualifiers )
    406                                         || widen.second )
    407                         ) {
    408                                 result = new ast::BasicType{ kind, basic->qualifiers | type2->qualifiers };
    409                         }
     398                } else if ( auto type2AsAttr = dynamic_cast< const ast::EnumAttrType * >( type2 ) ) {
     399            if ( type2AsAttr->attr == ast::EnumAttribute::Posn ) {
     400                            ast::BasicKind kind = commonTypes[ basic->kind ][ ast::BasicKind::SignedInt ];
     401                            if (
     402                                    ( ( kind == basic->kind && basic->qualifiers >= type2->qualifiers )
     403                                            || widen.first )
     404                                    && ( ( kind != basic->kind && basic->qualifiers <= type2->qualifiers )
     405                                            || widen.second )
     406                            ) {
     407                                    result = new ast::BasicType{ kind, basic->qualifiers | type2->qualifiers };
     408                            }
     409            }
    410410                }
    411411        }
    … …  
    426426                result = voidPtr;
    427427                add_qualifiers( result, oPtr->qualifiers );
    428         }
    429 
    430         // For a typed enum, we want to unify type1 with the base type of the enum
    431         bool tryResolveWithTypedEnum( const ast::Type * type1 ) {
    432                 if (auto enumInst = dynamic_cast<const ast::EnumInstType *> (type2) ) {
    433                         ast::OpenVarSet newOpen{ open };
    434                         if (enumInst->base->base
    435                                 && unifyExact(type1, enumInst->base->base, tenv, need, have, newOpen, widen)) {
    436                                         result = type1;
    437                                 return true;
    438                         }
    439                 }
    440                 return false;
    441428        }
    442429
    … …  
    607594                        result = pointer;
    608595                        add_qualifiers( result, type2->qualifiers );
    609                 } else {
    610                         tryResolveWithTypedEnum( pointer );
    611                 }
    612         }
    613 
    614         void postvisit( const ast::ArrayType * arr ) {
    615                 // xxx - does it make sense?
    616                 tryResolveWithTypedEnum( arr );
    617         }
     596                }
     597        }
     598
     599        void postvisit( const ast::ArrayType * ) {}
    618600
    619601        void postvisit( const ast::ReferenceType * ref ) {
    … …  
    659641        }
    660642
    661         void postvisit( const ast::FunctionType * func) {
    662                 tryResolveWithTypedEnum( func );
    663         }
    664 
    665         void postvisit( const ast::StructInstType * inst ) {
    666                 tryResolveWithTypedEnum( inst );
    667         }
    668 
    669         void postvisit( const ast::UnionInstType * inst ) {
    670                 tryResolveWithTypedEnum( inst );
    671         }
     643        void postvisit( const ast::FunctionType * ) {}
     644
     645        void postvisit( const ast::StructInstType * ) {}
     646
     647        void postvisit( const ast::UnionInstType * ) {}
    672648
    673649        void postvisit( const ast::EnumInstType * enumInst ) {
    674                 // if ( dynamic_cast<const ast::EnumPosType *>(enumInst) ) {
    675                 //      result = enumInst;
    676                 // } else
    677                 if (!dynamic_cast<const ast::EnumInstType *>(type2)) {
    678                         result = commonType( type2, enumInst, tenv, need, have, open, widen);
    679                 }
    680         }
    681 
    682         void postvisit( const ast::EnumPosType * enumPos ) {
    683                 if ( auto type2AsPos = dynamic_cast<const ast::EnumPosType *>(type2) ) {
    684                         // result = commonType( type2AsPos->instance, enumPos->instance, tenv, need, have, open, widen );
    685                         // result = enumPos;
    686                         if ( enumPos->instance->base->name == type2AsPos->instance->base->name ) {
    687                                 result = type2;
    688                         }
    689                 } else if ( dynamic_cast<const ast::BasicType *>(type2) ) {
    690                         result = type2;
    691                 }
    692         }
     650                if ( enumInst->base && !enumInst->base->base ) {
     651                        auto basicType = new ast::BasicType( ast::BasicKind::UnsignedInt );
     652                        result = commonType( basicType, type2, tenv, need, have, open, widen);
     653                }
     654        }
     655
     656        void postvisit( const ast::EnumAttrType * ) {}
    693657
    694658        void postvisit( const ast::TraitInstType * ) {}
    … …  
    696660        void postvisit( const ast::TypeInstType * ) {}
    697661
    698         void postvisit( const ast::TupleType * tuple ) {
    699                 tryResolveWithTypedEnum( tuple );
    700         }
     662        void postvisit( const ast::TupleType * ) {}
    701663
    702664        void postvisit( const ast::VarArgsType * ) {}
    … …  
    712674                } else if ( widen.second && dynamic_cast< const ast::OneType * >( type2 ) ) {
    713675                        result = new ast::BasicType{
    714                                 ast::BasicType::SignedInt, zero->qualifiers | type2->qualifiers };
     676                                ast::BasicKind::SignedInt, zero->qualifiers | type2->qualifiers };
    715677                } else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( type2 ) ) {
    716678                        const ast::EnumDecl * enumDecl = enumInst->base;
    717                         if ( enumDecl->base ) {
    718                                 if ( tryResolveWithTypedEnum( zero ) )
    719                                         add_qualifiers( result, zero->qualifiers );
    720                         } else {
     679                        if ( !enumDecl->base ) {
    721680                                if ( widen.second || zero->qualifiers <= type2->qualifiers ) {
    722681                                        result = type2;
    … …  
    736695                } else if ( widen.second && dynamic_cast< const ast::ZeroType * >( type2 ) ) {
    737696                        result = new ast::BasicType{
    738                                 ast::BasicType::SignedInt, one->qualifiers | type2->qualifiers };
     697                                ast::BasicKind::SignedInt, one->qualifiers | type2->qualifiers };
    739698                } else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( type2 ) ) {
    740                         const ast::EnumDecl * enumBase = enumInst->base;
    741                         if ( enumBase->base ) {
    742                                 if ( tryResolveWithTypedEnum( one ))
    743                                         add_qualifiers( result, one->qualifiers );
    744                         } else {
     699                        const ast::EnumDecl * enumDecl = enumInst->base;
     700                        if ( !enumDecl->base ) {
    745701                                if ( widen.second || one->qualifiers <= type2->qualifiers ) {
    746702                                        result = type2;

  • src/ResolvExpr/ConversionCost.cc

    rda87eaf r4e08a54  
    5959        // GENERATED START, DO NOT EDIT
    6060        // GENERATED BY BasicTypes-gen.cc
    61         static const int costMatrix[ast::BasicType::NUMBER_OF_BASIC_TYPES][ast::BasicType::NUMBER_OF_BASIC_TYPES] = { // path length from root to node
     61        static const int costMatrix[ast::BasicKind::NUMBER_OF_BASIC_TYPES][ast::BasicKind::NUMBER_OF_BASIC_TYPES] = { // path length from root to node
    6262                /*               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 */
    6363                /*      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, },
    … …  
    101101        // GENERATED END
    102102        static_assert(
    103                 sizeof(costMatrix)/sizeof(costMatrix[0][0]) == ast::BasicType::NUMBER_OF_BASIC_TYPES * ast::BasicType::NUMBER_OF_BASIC_TYPES,
     103                sizeof(costMatrix)/sizeof(costMatrix[0][0]) == ast::BasicKind::NUMBER_OF_BASIC_TYPES * ast::BasicKind::NUMBER_OF_BASIC_TYPES,
    104104                "Missing row in the cost matrix"
    105105        );
    … …  
    107107        // GENERATED START, DO NOT EDIT
    108108        // GENERATED BY BasicTypes-gen.cc
    109         static const int signMatrix[ast::BasicType::NUMBER_OF_BASIC_TYPES][ast::BasicType::NUMBER_OF_BASIC_TYPES] = { // number of sign changes in safe conversion
     109        static const int signMatrix[ast::BasicKind::NUMBER_OF_BASIC_TYPES][ast::BasicKind::NUMBER_OF_BASIC_TYPES] = { // number of sign changes in safe conversion
    110110                /*               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 */
    111111                /*      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, },
    … …  
    148148        // GENERATED END
    149149        static_assert(
    150                 sizeof(signMatrix)/sizeof(signMatrix[0][0]) == ast::BasicType::NUMBER_OF_BASIC_TYPES * ast::BasicType::NUMBER_OF_BASIC_TYPES,
     150                sizeof(signMatrix)/sizeof(signMatrix[0][0]) == ast::BasicKind::NUMBER_OF_BASIC_TYPES * ast::BasicKind::NUMBER_OF_BASIC_TYPES,
    151151                "Missing row in the sign matrix"
    152152        );
    … …  
    278278        if ( const ast::BasicType * dstAsBasic = dynamic_cast< const ast::BasicType * >( dst ) ) {
    279279                conversionCostFromBasicToBasic( basicType, dstAsBasic );
    280         }
    281         else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
    282                 auto enumDecl = enumInst->base;
    283                 if ( enumDecl->base.get() ) {
    284                         // cost = costCalc( basicType, baseType, srcIsLvalue, symtab, env );
    285                         // cost.incUnsafe();
    286                         cost = Cost::infinity;
    287                 } else {
    288             cost = Cost::unsafe;
    289                 }
    290         } else if ( dynamic_cast< const ast::EnumPosType *>(dst) ) {
    291                 static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
     280        } else if ( dynamic_cast< const ast::EnumAttrType *>(dst) ) {
     281                static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicKind::SignedInt ) };
    292282                cost = costCalc( basicType, integer, srcIsLvalue, symtab, env );
     283        } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
     284                if ( dstAsEnumInst->base && !dstAsEnumInst->base->base ) {
     285                        cost = Cost::zero;
     286                        cost.incUnsafe();
     287                }
    293288        }
    294289}
    … …  
    366361}
    367362
    368 void ConversionCost::postvisit( const ast::EnumInstType * ) {
    369         static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
     363void ConversionCost::postvisit( const ast::EnumInstType * inst ) {
     364        if ( auto dstAsInst = dynamic_cast<const ast::EnumInstType *>( dst ) ) {
     365                if (inst->base && dstAsInst->base) {
     366                        if (inst->base->name == dstAsInst->base->name) {
     367                                cost = Cost::zero;
     368                                return;
     369                        }
     370                }
     371                return;
     372        }
     373        static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicKind::SignedInt ) };
    370374        cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
    371375        if ( cost < Cost::unsafe ) {
    … …  
    374378}
    375379
    376 void ConversionCost::postvisit( const ast::EnumPosType * src ) {
    377         if ( dynamic_cast<const ast::EnumPosType *>( dst ) ) {
    378                 // cost = costCalc( src->instance, dstBase->instance, srcIsLvalue, symtab, env );
    379                 // if ( cost < Cost::unsafe ) cost.incSafe();
    380                 cost = Cost::zero;
    381         } else if ( auto dstBase = dynamic_cast<const ast::EnumInstType *>( dst ) ) {
    382                 cost = costCalc( src->instance, dstBase, srcIsLvalue, symtab, env );
    383                 if ( cost < Cost::unsafe ) cost.incSafe();
    384         } else {
    385                 static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
    386                 cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
    387                 if ( cost < Cost::unsafe ) {
    388                         cost.incSafe();
    389                 }
    390         }
    391 
     380void ConversionCost::postvisit( const ast::EnumAttrType * src ) {
     381    auto dstAsEnumAttrType = dynamic_cast<const ast::EnumAttrType *>(dst);
     382        assert( src->attr != ast::EnumAttribute::Label );
     383    if ( src->attr == ast::EnumAttribute::Value ) {
     384        if ( dstAsEnumAttrType && dstAsEnumAttrType->attr == ast::EnumAttribute::Value) {
     385            cost = costCalc( src->instance, dstAsEnumAttrType->instance, srcIsLvalue, symtab, env );
     386        } else {
     387            auto baseType = src->instance->base->base;
     388            cost = costCalc( baseType, dst, srcIsLvalue, symtab, env );
     389                        if ( cost < Cost::infinity ) {
     390                                cost.incUnsafe();
     391                        }
     392        }
     393    } else { // ast::EnumAttribute::Posn
     394        if ( auto dstBase = dynamic_cast<const ast::EnumInstType *>( dst ) ) {
     395                    cost = costCalc( src->instance, dstBase, srcIsLvalue, symtab, env );
     396                    if ( cost < Cost::unsafe ) cost.incSafe();
     397            } else {
     398                    static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicKind::SignedInt ) };
     399                    cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
     400                    if ( cost < Cost::unsafe ) {
     401                            cost.incSafe();
     402                    }
     403            }
     404    }
    392405}
    393406
    … …  
    448461        } else if ( const ast::BasicType * dstAsBasic =
    449462                        dynamic_cast< const ast::BasicType * >( dst ) ) {
    450                 int tableResult = costMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ];
     463                int tableResult = costMatrix[ ast::BasicKind::SignedInt ][ dstAsBasic->kind ];
    451464                if ( -1 == tableResult ) {
    452465                        cost = Cost::unsafe;
    … …  
    454467                        cost = Cost::zero;
    455468                        cost.incSafe( tableResult + 1 );
    456                         cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] );
     469                        cost.incSign( signMatrix[ ast::BasicKind::SignedInt ][ dstAsBasic->kind ] );
    457470                }
    458471                // this has the effect of letting any expr such as x+0, x+1 to be typed
    … …  
    466479                cost.incSafe( maxIntCost + 2 );
    467480                // assuming 0p is supposed to be used for pointers?
     481        } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
     482                if ( dstAsEnumInst->base && !dstAsEnumInst->base->base ) {
     483                        cost = Cost::zero;
     484                        cost.incUnsafe();
     485                }
    468486        }
    469487}
    … …  
    475493        } else if ( const ast::BasicType * dstAsBasic =
    476494                        dynamic_cast< const ast::BasicType * >( dst ) ) {
    477                 int tableResult = costMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ];
     495                int tableResult = costMatrix[ ast::BasicKind::SignedInt ][ dstAsBasic->kind ];
    478496                if ( -1 == tableResult ) {
    479497                        cost = Cost::unsafe;
    … …  
    481499                        cost = Cost::zero;
    482500                        cost.incSafe( tableResult + 1 );
    483                         cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] );
     501                        cost.incSign( signMatrix[ ast::BasicKind::SignedInt ][ dstAsBasic->kind ] );
     502                }
     503        } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
     504                if ( dstAsEnumInst->base && !dstAsEnumInst->base->base ) {
     505                        cost = Cost::zero;
     506                        cost.incUnsafe();
    484507                }
    485508        }

  • src/ResolvExpr/ConversionCost.h

    rda87eaf r4e08a54  
    7272        void postvisit( const ast::ZeroType * zeroType );
    7373        void postvisit( const ast::OneType * oneType );
    74         void postvisit( const ast::EnumPosType * posType );
     74        void postvisit( const ast::EnumAttrType * posType );
    7575private:
    7676        // refactor for code resue

  • src/ResolvExpr/PtrsCastable.cc

    rda87eaf r4e08a54  
    100100                                result = 1;
    101101                        } else if ( auto bt = dynamic_cast< const ast::BasicType * >( dst ) ) {
    102                                 if ( bt->kind == ast::BasicType::SignedInt ) {
     102                                if ( bt->kind == ast::BasicKind::SignedInt ) {
    103103                                        result = 0;
    104104                                } else {

  • src/ResolvExpr/ResolveTypeof.cc

    rda87eaf r4e08a54  
    6363                        if ( newType.as< ast::EnumInstType >() ) {
    6464                                newType = new ast::BasicType(
    65                                         ast::BasicType::SignedInt, newType->qualifiers, copy(newType->attributes) );
     65                                        ast::BasicKind::SignedInt, newType->qualifiers, copy(newType->attributes) );
    6666                        }
    6767                        reset_qualifiers(
    … …  
    9191                auto mutType = mutate(arrayType);
    9292                auto globalSizeType = context.global.sizeType;
    93                 ast::ptr<ast::Type> sizetype = globalSizeType ? globalSizeType : new ast::BasicType(ast::BasicType::LongUnsignedInt);
     93                ast::ptr<ast::Type> sizetype = globalSizeType ? globalSizeType : new ast::BasicType( ast::BasicKind::LongUnsignedInt );
    9494                mutType->dimension = findSingleExpression(arrayType->dimension, sizetype, context );
    9595

  • src/ResolvExpr/Resolver.cc

    rda87eaf r4e08a54  
    351351        bool isCharType( const ast::Type * t ) {
    352352                if ( auto bt = dynamic_cast< const ast::BasicType * >( t ) ) {
    353                         return bt->kind == ast::BasicType::Char
    354                                 || bt->kind == ast::BasicType::SignedChar
    355                                 || bt->kind == ast::BasicType::UnsignedChar;
     353                        return bt->kind == ast::BasicKind::Char
     354                                || bt->kind == ast::BasicKind::SignedChar
     355                                || bt->kind == ast::BasicKind::UnsignedChar;
    356356                }
    357357                return false;
    … …  
    458458                        if (attr->params.size() == 1) {
    459459                                auto arg = attr->params.front();
    460                                 auto resolved = ResolvExpr::findSingleExpression( arg, new ast::BasicType( ast::BasicType::LongLongSignedInt ), context );
     460                                auto resolved = ResolvExpr::findSingleExpression( arg, new ast::BasicType( ast::BasicKind::LongLongSignedInt ), context );
    461461                                auto result = eval(arg);
    462462
    … …  
    624624                        objectDecl = fixObjectType( objectDecl, context );
    625625                        currentObject = ast::CurrentObject{
    626                                 objectDecl->location, new ast::BasicType{ ast::BasicType::SignedInt } };
     626                                objectDecl->location, new ast::BasicType{ ast::BasicKind::SignedInt } };
    627627                }
    628628        } else {
    … …  
    10951095                // resolve the timeout as a size_t, the conditions like IfStmt, and stmts normally
    10961096                ast::ptr< ast::Type > target =
    1097                         new ast::BasicType{ ast::BasicType::LongLongUnsignedInt };
     1097                        new ast::BasicType{ ast::BasicKind::LongLongUnsignedInt };
    10981098                auto timeout_time = findSingleExpression( stmt->timeout_time, target, context );
    10991099                auto timeout_cond = findCondExpression( stmt->timeout_cond, context );

  • src/ResolvExpr/Unify.cc

    rda87eaf r4e08a54  
    274274                void previsit( const ast::Node * ) { visit_children = false; }
    275275
    276                 void postvisit( const ast::VoidType * ) {
    277                         result = dynamic_cast< const ast::VoidType * >( type2 );
     276                void postvisit( const ast::VoidType * vt) {
     277                        result = dynamic_cast< const ast::VoidType * >( type2 )
     278                                || tryToUnifyWithEnumValue(vt, type2, tenv, need, have, open, noWiden());
     279                        ;
    278280                }
    279281
    … …  
    282284                                result = basic->kind == basic2->kind;
    283285                        }
     286                        result = result || tryToUnifyWithEnumValue(basic, type2, tenv, need, have, open, noWiden());
    284287                }
    285288
    … …  
    290293                                        noWiden());
    291294                        }
     295                        result = result || tryToUnifyWithEnumValue(pointer, type2, tenv, need, have, open, noWiden());
    292296                }
    293297
    … …  
    307311
    308312                        result = unifyExact(
    309                                 array->base, array2->base, tenv, need, have, open, noWiden());
     313                                array->base, array2->base, tenv, need, have, open, noWiden())
     314                                || tryToUnifyWithEnumValue(array, type2, tenv, need, have, open, noWiden());
    310315                }
    311316
    … …  
    399404                }
    400405
     406                bool tryToUnifyWithEnumValue( const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env,
     407                        ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
     408                        WidenMode widen) {
     409                        if ( auto attrType2 = dynamic_cast<const ast::EnumAttrType *>(type2)) {
     410                                if (attrType2->attr == ast::EnumAttribute::Value) {
     411                                        return unifyExact( type1, attrType2->instance->base->base, env, need, have, open,
     412                                                widen);
     413                                } else if (attrType2->attr == ast::EnumAttribute::Posn) {
     414                                        return unifyExact( type1, attrType2->instance, env, need, have, open, widen );
     415                                }
     416                        }
     417                        return false;
     418                }
     419
    401420        public:
    402421                void postvisit( const ast::FunctionType * func ) {
    … …  
    507526                void postvisit( const ast::StructInstType * aggrType ) {
    508527                        handleGenericRefType( aggrType, type2 );
     528                        result = result || tryToUnifyWithEnumValue(aggrType, type2, tenv, need, have, open, noWiden());
    509529                }
    510530
    511531                void postvisit( const ast::UnionInstType * aggrType ) {
    512532                        handleGenericRefType( aggrType, type2 );
     533                        result = result || tryToUnifyWithEnumValue(aggrType, type2, tenv, need, have, open, noWiden());
    513534                }
    514535
    515536                void postvisit( const ast::EnumInstType * aggrType ) {
    516537                        handleRefType( aggrType, type2 );
    517                 }
    518 
    519                 void postvisit( const ast::EnumPosType * posType ) {
     538                        result = result || tryToUnifyWithEnumValue(aggrType, type2, tenv, need, have, open, noWiden());
     539                }
     540
     541                void postvisit( const ast::EnumAttrType * enumAttr ) {
    520542                        // Lazy approach for now
    521                         auto otherPos = dynamic_cast< const ast::EnumPosType *>(type2);
    522                         if ( otherPos ) {
    523                                 if ( otherPos->instance->base->name == posType->instance->base->name )
    524                                         result = otherPos;
    525                         }
     543                        if ( auto otherPos = dynamic_cast< const ast::EnumAttrType *>(type2) ) {
     544                            if ( enumAttr->match(otherPos) ) {
     545                                    result = otherPos;
     546                            }
     547            } 
    526548                }
    527549
    528550                void postvisit( const ast::TraitInstType * aggrType ) {
    529551                        handleRefType( aggrType, type2 );
     552                        result = result || tryToUnifyWithEnumValue(aggrType, type2, tenv, need, have, open, noWiden());
    530553                }
    531554
    … …  
    536559                                this->result = otherInst;
    537560                        }
     561                        result = result || tryToUnifyWithEnumValue(typeInst, type2, tenv, need, have, open, noWiden());
    538562                }
    539563
    … …  
    610634                        auto types2 = flatten( flat2 );
    611635
    612                         result = unifyList( types, types2, tenv, need, have, open );
    613                 }
    614 
    615                 void postvisit( const ast::VarArgsType * ) {
    616                         result = dynamic_cast< const ast::VarArgsType * >( type2 );
    617                 }
    618 
    619                 void postvisit( const ast::ZeroType * ) {
    620                         result = dynamic_cast< const ast::ZeroType * >( type2 );
    621                 }
    622 
    623                 void postvisit( const ast::OneType * ) {
    624                         result = dynamic_cast< const ast::OneType * >( type2 );
     636                        result = unifyList( types, types2, tenv, need, have, open )
     637                                || tryToUnifyWithEnumValue(tuple, type2, tenv, need, have, open, noWiden());
     638                }
     639
     640                void postvisit( const ast::VarArgsType * vat) {
     641                        result = dynamic_cast< const ast::VarArgsType * >( type2 )
     642                                || tryToUnifyWithEnumValue(vat, type2, tenv, need, have, open, noWiden());
     643                }
     644
     645                void postvisit( const ast::ZeroType * zt) {
     646                        result = dynamic_cast< const ast::ZeroType * >( type2 )
     647                                || tryToUnifyWithEnumValue(zt, type2, tenv, need, have, open, noWiden());
     648                }
     649
     650                void postvisit( const ast::OneType * ot) {
     651                        result = dynamic_cast< const ast::OneType * >( type2 )
     652                                || tryToUnifyWithEnumValue(ot, type2, tenv, need, have, open, noWiden());
    625653                }
    626654        };

  • src/SymTab/GenImplicitCall.cpp

    rda87eaf r4e08a54  
    133133
    134134        ast::ptr< ast::DeclWithType > index = new ast::ObjectDecl(
    135                 loc, indexName.newName(), new ast::BasicType( ast::BasicType::SignedInt ),
     135                loc, indexName.newName(), new ast::BasicType( ast::BasicKind::SignedInt ),
    136136                new ast::SingleInit( loc, begin ) );
    137137        ast::ptr< ast::Expr > indexVar = new ast::VariableExpr( loc, index );

  • src/SymTab/Mangler.cc

    rda87eaf r4e08a54  
    5858        void postvisit( const ast::OneType * oneType );
    5959        void postvisit( const ast::QualifiedType * qualType );
    60 
    61         void postvisit( const ast::EnumPosType * posType );
     60        void postvisit( const ast::EnumAttrType * posType );
    6261
    6362        /// The result is the current constructed mangled name.
    … …  
    143142void Mangler::postvisit( const ast::BasicType * basicType ) {
    144143        printQualifiers( basicType );
    145         assertf( basicType->kind < ast::BasicType::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->kind );
     144        assertf( basicType->kind < ast::BasicKind::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->kind );
    146145        mangleName += Encoding::basicTypes[ basicType->kind ];
    147146}
    … …  
    281280}
    282281
    283 void Mangler::postvisit( const ast::EnumPosType * pos ) {
    284         postvisit( pos->instance );
    285         mangleName += "_pos";
     282void Mangler::postvisit( const ast::EnumAttrType * enumAttr ) {
     283        postvisit( enumAttr->instance );
     284        // mangleName += "_pos";
     285    switch ( enumAttr->attr )
     286    {
     287        case ast::EnumAttribute::Label:
     288            mangleName += "_label_";
     289            break;
     290        case ast::EnumAttribute::Posn:
     291                        mangleName += "_posn_";
     292            break;
     293        case ast::EnumAttribute::Value:
     294            mangleName += "_value_";
     295            break;
     296    }
     297
    286298}
    287299

  • src/SymTab/ManglerCommon.cc

    rda87eaf r4e08a54  
    4141//   - "Di" char32_t
    4242//   - "Ds" char16_t
    43 const std::string basicTypes[ast::BasicType::NUMBER_OF_BASIC_TYPES] = {
     43const std::string basicTypes[ast::BasicKind::NUMBER_OF_BASIC_TYPES] = {
    4444        "b",        // _Bool
    4545        "c",        // char
    … …  
    8181// GENERATED END
    8282static_assert(
    83         sizeof(basicTypes) / sizeof(basicTypes[0]) == ast::BasicType::NUMBER_OF_BASIC_TYPES,
     83        sizeof(basicTypes) / sizeof(basicTypes[0]) == ast::BasicKind::NUMBER_OF_BASIC_TYPES,
    8484        "Each basic type kind should have a corresponding mangler letter"
    8585);

  • src/Tuples/TupleAssignment.cc

    rda87eaf r4e08a54  
    3535#include "InitTweak/GenInit.h"             // for genCtorInit
    3636#include "InitTweak/InitTweak.h"           // for getPointerBase, isAssignment
     37#include "ResolvExpr/CandidateFinder.hpp"  // for CandidateFinder
    3738#include "ResolvExpr/Cost.h"               // for Cost
    3839#include "ResolvExpr/Resolver.h"           // for resolveCtorInit

  • src/Tuples/TupleExpansion.cpp

    rda87eaf r4e08a54  
    106106                        assignUnq = commaExpr->arg1;
    107107                }
    108                 auto finished = new ast::ObjectDecl( loc, toString( "_unq", id, "_finished_" ), new ast::BasicType( ast::BasicType::Kind::Bool ),
     108                auto finished = new ast::ObjectDecl( loc, toString( "_unq", id, "_finished_" ), new ast::BasicType( ast::BasicKind::Bool ),
    109109                        new ast::SingleInit( loc, ast::ConstantExpr::from_int( loc, 0 ) ), {}, ast::Linkage::Cforall );
    110110                declsToAddBefore.push_back( finished );
    … …  
    175175                        new ast::ObjectDecl( location,
    176176                                "dummy",
    177                                 new ast::BasicType( ast::BasicType::SignedInt ),
     177                                new ast::BasicType( ast::BasicKind::SignedInt ),
    178178                                nullptr,
    179179                                ast::Storage::Classes(),

  • src/Tuples/Tuples.h

    rda87eaf r4e08a54  
    2121#include "AST/Fwd.hpp"
    2222#include "AST/Node.hpp"
    23 #include "ResolvExpr/CandidateFinder.hpp"
     23namespace ResolvExpr {
     24        class CandidateFinder;
     25}
    2426
    2527namespace Tuples {

  • src/Validate/Autogen.cpp

    rda87eaf r4e08a54  
    196196
    197197        bool shouldAutogen() const final { return true; }
    198         void genAttrFuncForward();
    199         void genPosFunctions();
    200198private:
    201199        void genFuncBody( ast::FunctionDecl * decl ) final;
    202200        void genFieldCtors() final;
    203201        const ast::Decl * getDecl() const final { return decl; }
    204 
    205         ast::FunctionDecl * genPosProto() const;
    206         ast::FunctionDecl * genLabelProto() const;
    207         ast::FunctionDecl * genValueProto() const;
    208         ast::FunctionDecl * genSuccProto() const;
    209         ast::FunctionDecl * genPredProto() const;
    210 
    211         ast::FunctionDecl * genSuccPosProto() const;
    212         ast::FunctionDecl * genPredPosProto() const;
    213 
    214         ast::FunctionDecl * genSuccPredFunc( bool succ );
    215         // ast::FunctionDecl * genPredFunc();
    216202};
    217203
    … …  
    256242        enumInst.base = enumDecl;
    257243        EnumFuncGenerator gen( enumDecl, &enumInst, functionNesting );
    258         if ( enumDecl->base ) {
    259                 gen.genAttrFuncForward();
    260                 gen.genPosFunctions();
    261         }
    262244        gen.generateAndAppendFunctions( declsToAddAfter );
    263245}
    … …  
    418400}
    419401
    420 /// Use the current type T to create `void ?{}(T & _dst)`.
     402/// Use the current type T to create `void ^?{}(T & _dst)`.
    421403ast::FunctionDecl * FuncGenerator::genDtorProto() const {
    422404        // The destructor must be mutex on a concurrent type.
    … …  
    777759}
    778760
    779 ast::FunctionDecl * EnumFuncGenerator::genPosProto() const {
    780         return genProto( "posE",
    781                 { new ast::ObjectDecl( getLocation(), "_i",
    782                 new ast::EnumInstType( decl ) )},
    783                 { new ast::ObjectDecl( getLocation(), "_ret",
    784                 new ast::BasicType{ ast::BasicType::UnsignedInt } )} );
    785 }
    786 
    787 ast::FunctionDecl * EnumFuncGenerator::genLabelProto() const {
    788         return genProto( "labelE",
    789                 { new ast::ObjectDecl( getLocation(), "_i",
    790                 new ast::EnumInstType( decl ) ) },
    791                 { new ast::ObjectDecl( getLocation(), "_ret",
    792                 new ast::PointerType( new ast::BasicType{ ast::BasicType::Char } ) ) } );
    793 }
    794 
    795 ast::FunctionDecl * EnumFuncGenerator::genValueProto() const {
    796         return genProto( "valueE",
    797                 { new ast::ObjectDecl( getLocation(), "_i", new ast::EnumInstType( decl ) )},
    798                 { new ast::ObjectDecl( getLocation(), "_ret", ast::deepCopy( decl->base ) ) } );
    799 }
    800 
    801 ast::FunctionDecl * EnumFuncGenerator::genSuccProto() const {
    802         return genProto( "succ",
    803                 { new ast::ObjectDecl( getLocation(), "_i", new ast::EnumInstType( decl ) )},
    804                 { new ast::ObjectDecl( getLocation(), "_ret", new ast::EnumInstType( decl ))} );
    805 }
    806 
    807 ast::FunctionDecl * EnumFuncGenerator::genPredProto() const {
    808         return genProto( "pred",
    809                 { new ast::ObjectDecl( getLocation(), "_i", new ast::EnumInstType( decl ))},
    810                 { new ast::ObjectDecl( getLocation(), "_ret", new ast::EnumInstType( decl ))} );
    811 }
    812 
    813 ast::FunctionDecl * EnumFuncGenerator::genSuccPosProto() const {
    814         return genProto( "_successor_",
    815                 { new ast::ObjectDecl( getLocation(), "_i",
    816                         new ast::EnumPosType( new ast::EnumInstType( decl ) ) )},
    817                 {
    818                         new ast::ObjectDecl( getLocation(), "_ret",
    819                         new ast::EnumPosType( new ast::EnumInstType( decl ) ) )
    820                 } );
    821 }
    822 
    823 ast::FunctionDecl * EnumFuncGenerator::genPredPosProto() const {
    824         return genProto( "_predessor_",
    825                 { new ast::ObjectDecl( getLocation(), "_i",
    826                         new ast::EnumPosType( new ast::EnumInstType( decl ) ) )},
    827                 {
    828                         new ast::ObjectDecl( getLocation(), "_ret",
    829                         new ast::EnumPosType( new ast::EnumInstType( decl ) ) )
    830                 } );
    831 }
    832 
    833 ast::FunctionDecl * EnumFuncGenerator::genSuccPredFunc( bool succ ) {
    834         ast::FunctionDecl * decl = succ? genSuccPosProto(): genPredPosProto();
    835         produceForwardDecl( decl );
    836 
    837         const CodeLocation& location = getLocation();
    838 
    839         auto & params = decl->params;
    840         assert( params.size() == 1 );
    841         auto param = params.front().strict_as<ast::ObjectDecl>();
    842 
    843         auto newReturn = new ast::ObjectDecl( location, "_returns",
    844                 new ast::BasicType{ ast::BasicType::SignedInt} );
    845        
    846 
    847         ast::UntypedExpr * addOneExpr = new ast::UntypedExpr( location,
    848                 new ast::NameExpr( location, succ? "?+?": "?-?" )
    849         );
    850         addOneExpr->args.push_back(
    851                 new ast::CastExpr( location,
    852                         new ast::VariableExpr( location, param ),
    853                         new ast::BasicType{ ast::BasicType::SignedInt }
    854                 )
    855         );
    856         addOneExpr->args.push_back(
    857                 ast::ConstantExpr::from_int( location, 1 )
    858         );
    859 
    860         ast::UntypedExpr * assignExpr = new ast::UntypedExpr( location,
    861                 new ast::NameExpr( location, "?=?" )
    862         );
    863         assignExpr->args.push_back(     
    864                 new ast::VariableExpr( location, newReturn )
    865         );
    866         assignExpr->args.push_back(
    867                 addOneExpr
    868         );
    869 
    870         decl->stmts = new ast::CompoundStmt( location,
    871                 {
    872                         new ast::DeclStmt( location, newReturn ),
    873                         new ast::ExprStmt( location, assignExpr ),
    874                         new ast::ReturnStmt( location,
    875                                 new ast::VariableExpr( location, newReturn ))
    876                 } );
    877        
    878         return decl;
    879 }
    880 
    881 void EnumFuncGenerator::genAttrFuncForward() { 
    882         if ( decl->base ) {
    883                 ast::FunctionDecl *(EnumFuncGenerator::*attrProtos[5])() const = {
    884                         &EnumFuncGenerator::genPosProto, &EnumFuncGenerator::genLabelProto,
    885                         &EnumFuncGenerator::genValueProto, &EnumFuncGenerator::genSuccProto,
    886                         &EnumFuncGenerator::genPredProto
    887                         // ,&EnumFuncGenerator::genSuccPosProto,
    888                         // &EnumFuncGenerator::genPredPosProto
    889                 };
    890                 for ( auto & generator : attrProtos ) {
    891                         produceForwardDecl( (this->*generator)() );
    892                 }
    893         }
    894 }
    895 
    896 void EnumFuncGenerator::genPosFunctions() {
    897         if ( decl->base ) {
    898                 ast::FunctionDecl * succ = genSuccPredFunc( true );
    899                 ast::FunctionDecl * pred = genSuccPredFunc( false );
    900                 produceDecl( succ );
    901                 produceDecl( pred );
    902         }
    903 
    904 }
    905 
    906761void TypeFuncGenerator::genFieldCtors() {
    907762        // Opaque types do not have field constructors.

  • src/Validate/GenericParameter.cpp

    rda87eaf r4e08a54  
    289289                return new ast::TypeExpr( expr->location,
    290290                        new ast::ArrayType(
    291                                 new ast::BasicType( ast::BasicType::Char ),
     291                                new ast::BasicType( ast::BasicKind::Char ),
    292292                                expr,
    293293                                ast::VariableLen,

  • src/Validate/ReplacePseudoFunc.cpp

    rda87eaf r4e08a54  
    1616
    1717namespace {
    18 
    19 std::set<std::string> queryLabels;
    20 std::set<std::string> queryValues;
    21 
    22 struct ReplaceEnumInstWithPos final : public ast::WithShortCircuiting {
    23     const ast::ObjectDecl* postvisit(const ast::ObjectDecl* decl) {
    24         auto enumInst = decl->type.strict_as<ast::EnumInstType>();
    25         auto enumPos = new ast::EnumPosType(enumInst);
    26         auto ret = ast::mutate_field(decl, &ast::ObjectDecl::type, enumPos);
    27         ret = ast::mutate_field(ret, &ast::ObjectDecl::mangleName,
    28                                 Mangle::mangle(ret));
    29         return ret;
    30     }
    31 };
    32 
    33 const inline std::string getValueArrayName(std::string enumName) {
    34     return "values_" + enumName;
    35 }
    36 
    37 // struct AutoInit {
    38 //     ast::EnumDecl const* postvisit( const ast::EnumDecl* expr );
    39 // };
    40 
    41 struct WrapEnumValueExpr final : public ast::WithShortCircuiting,
    42                                  public ast::WithSymbolTable,
    43                                  public ast::WithConstTranslationUnit {
    44     void previsit(const ast::DeclStmt* expr);
    45     void previsit(const ast::ApplicationExpr* expr);
    46     void previsit(const ast::CastExpr* expr);
    47     void previsit(const ast::VariableExpr*) { visit_children = false; }
    48 
    49     ast::Expr const* postvisit(const ast::VariableExpr* expr);
    50 };
    51 
    52 struct FindGenEnumArray final : public ast::WithShortCircuiting {
    53     void previsit(const ast::ApplicationExpr* enumDecl);
    54 };
    55 
    56 struct PseudoFuncGenerateRoutine final : public ast::WithDeclsToAdd<>,
    57                                          public ast::WithSymbolTable,
    58                                          public ast::WithShortCircuiting,
    59                                          public ast::WithConstTranslationUnit {
    60     void previsit(const ast::EnumDecl* enumDecl);
    61 };
    62 
    63 struct ReplacePseudoFuncCore : public ast::WithShortCircuiting,
    64                                public ast::WithSymbolTable,
    65                                public ast::WithConstTranslationUnit {
    66     ast::Expr const* postvisit(ast::ApplicationExpr const* decl);
    67 };
    68 
    69 // ast::EnumDecl const * AutoInit::postvisit( const ast::EnumDecl * expr ) {
    70 //     for ( size_t i = 0; i < expr->members.size(); i++ ) {
    71 //         auto mem = expr->members[i].as<ast::ObjectDecl>();
    72 //         assert( mem );
    73 //         if ( mem->init )
    74 //     }
    75 //     return expr;
    76 // }
    77 
    78 void WrapEnumValueExpr::previsit(const ast::ApplicationExpr* expr) {
    79     auto varExpr = expr->func.as<ast::VariableExpr>();
    80     auto fname = ast::getFunctionName(expr);
    81     if (!varExpr || varExpr->var->linkage == ast::Linkage::Intrinsic) {
    82         if (fname == "?{}" || fname == "?=?") visit_children = false;
    83     }
    84 
    85     if (fname == "labelE" || fname == "valueE" || fname == "posE" ||
    86         fname == "pred" || fname == "succ") {
    87         visit_children = false;
    88     }
    89 }
    90 
    91 void WrapEnumValueExpr::previsit(const ast::DeclStmt*) {
    92     visit_children = false;
    93 }
    94 
    95 void WrapEnumValueExpr::previsit(const ast::CastExpr* expr) {
    96     if (expr->result && expr->result.as<ast::ReferenceType>()) {
    97         visit_children = false;
    98     }
    99 }
    100 
    101 ast::Expr const* WrapEnumValueExpr::postvisit(const ast::VariableExpr* expr) {
    102     if (!expr->result) {
    103         return expr;
    104     }
    105     if (auto enumInst = expr->result.as<ast::EnumInstType>()) {
    106         if (enumInst->base && enumInst->base->base) {
    107             auto untyped = new ast::UntypedExpr(
    108                 expr->location, new ast::NameExpr(expr->location, "valueE"),
    109                 {std::move(expr)});
    110             ResolvExpr::ResolveContext context{symtab, transUnit().global};
    111             auto result = ResolvExpr::findVoidExpression(untyped, context);
    112             ast::ptr<ast::ApplicationExpr> ret =
    113                 result.strict_as<ast::ApplicationExpr>();
    114             return ast::deepCopy(ret);
    115         }
    116     }
    117     return expr;
    118 }
    119 
    120 void FindGenEnumArray::previsit(const ast::ApplicationExpr* expr) {
    121     auto fname = ast::getFunctionName(expr);
    122     if (fname == "labelE" || fname == "valueE") {
    123         if (expr->args.size() != 1) {
    124             SemanticError(expr, "Position Expression only take one parameter");
    125         }
    126         const ast::VariableExpr* arg =
    127             expr->args.front().as<const ast::VariableExpr>();
    128         if (!arg) {
    129             SemanticError(expr, "Unimplement Pseudo Function Cases");
    130         }
    131         const ast::ObjectDecl* argAsVar = arg->var.as<const ast::ObjectDecl>();
    132         const std::string referredName = argAsVar->name;
    133         const ast::EnumInstType* argType =
    134             argAsVar->type.as<const ast::EnumInstType>();
    135         if (!argType) {
    136             SemanticError(
    137                 argAsVar,
    138                 "Position can only be used on an enumeration instance");
    139         }
    140         ast::ptr<ast::EnumDecl> base = argType->base;
    141         assert(base);
    142         if (fname == "labelE") queryLabels.insert(base->name);
    143         if (fname == "valueE") queryValues.insert(base->name);
    144     }
    145 }
    146 
    147 const ast::Init* getAutoInit(const CodeLocation& location,
    148                              const ast::Type* type,
    149                              ResolvExpr::ResolveContext context,
    150                              const ast::Init* prev) {
    151     if (auto prevInit = dynamic_cast<const ast::SingleInit*>(prev)) {
    152         auto prevInitExpr = prevInit->value;
    153         if (auto constInit = prevInitExpr.as<ast::ConstantExpr>()) {
    154             // Assume no string literal for now
    155             return new ast::SingleInit(
    156                 location, ast::ConstantExpr::from_int(
    157                               location, constInit->intValue() + 1));
    158         } else {
    159             auto untypedThisInit = new ast::UntypedExpr(
    160                 location, new ast::NameExpr(location, "?++"), {prevInitExpr});
    161             auto typedInit = ResolvExpr::findSingleExpression(untypedThisInit,
    162                                                               type, context);
    163             return new ast::SingleInit(location, typedInit);
    164         }
    165     }
    166     SemanticError(prev, "Auto Init a List is not implemented");
    167     return prev;
    168 }
    169 
    170 void PseudoFuncGenerateRoutine::previsit(const ast::EnumDecl* enumDecl) {
    171     visit_children = false;
    172     const CodeLocation& location = enumDecl->location;
    173     if (enumDecl->members.size() == 0 || !enumDecl->base) return;
    174 
    175     std::vector<ast::ptr<ast::Init>> inits;
    176     std::vector<ast::ptr<ast::Init>> labels;
    177     auto type = enumDecl->base;
    178 
    179     for (size_t i = 0; i < enumDecl->members.size(); i++) {
    180         ast::ptr<ast::Decl> mem = enumDecl->members.at(i);
    181         auto memAsObjectDecl = mem.as<ast::ObjectDecl>();
    182         assert(memAsObjectDecl);
    183         if (memAsObjectDecl->init) {
    184             inits.emplace_back(memAsObjectDecl->init);
    185         } else {
    186             const CodeLocation& location = mem->location;
    187             if (i == 0) {
    188                 inits.emplace_back(new ast::SingleInit(
    189                     location, ast::ConstantExpr::from_int(mem->location, 0)));
    190             } else {
    191                 inits.emplace_back(getAutoInit(
    192                     location, enumDecl->base,
    193                     ResolvExpr::ResolveContext{symtab, transUnit().global},
    194                     inits.at(i - 1).as<ast::SingleInit>()));
    195             }
    196         }
    197         labels.emplace_back(new ast::SingleInit(
    198             location, ast::ConstantExpr::from_string(location, mem->name)));
    199     }
    200     if (queryValues.count(enumDecl->name)) {
    201         auto init = new ast::ListInit(location, std::move(inits));
    202         const ast::ArrayType* arrT = new ast::ArrayType(
    203             enumDecl->base,
    204             ast::ConstantExpr::from_int(location, enumDecl->members.size()),
    205             ast::LengthFlag::FixedLen, ast::DimensionFlag::DynamicDim);
    206         ast::ObjectDecl* values = new ast::ObjectDecl(
    207             location, "values_" + enumDecl->name, arrT, init,
    208             ast::Storage::Static, ast::Linkage::AutoGen);
    209         symtab.addId(values);
    210         values->mangleName = Mangle::mangle(values);
    211         declsToAddAfter.push_back(values);
    212     }
    213     if (queryLabels.count(enumDecl->name)) {
    214         auto label_strings = new ast::ListInit(location, std::move(labels));
    215         auto labels = new ast::ObjectDecl(
    216             location, "labels_" + enumDecl->name,
    217             new ast::ArrayType(
    218                 new ast::PointerType(new ast::BasicType{ast::BasicType::Char}),
    219                 ast::ConstantExpr::from_int(location, enumDecl->members.size()),
    220                 ast::LengthFlag::FixedLen, ast::DimensionFlag::DynamicDim),
    221             label_strings, ast::Storage::Static, ast::Linkage::AutoGen);
    222         symtab.addId(labels);
    223         labels->mangleName = Mangle::mangle(labels);
    224         declsToAddAfter.push_back(labels);
    225     }
    226 }
    227 
    228 ast::ApplicationExpr const* resolveAttributeFunctions(
    229     const CodeLocation location, ResolvExpr::ResolveContext context,
    230     const ast::VariableExpr* arg, const ast::EnumDecl* base,
    231     const std::string& name) {
    232     ast::Expr* toResolve = new ast::NameExpr(location, name + base->name);
    233     // Find the request arrary
    234     auto arr = ResolvExpr::findVoidExpression(toResolve, context);
    235     assert(arr.get());
    236     auto arrAsVar = arr.strict_as<ast::VariableExpr>();
    237     // change EnumInstType to EnumPosType to avoid recursive resolution
    238     auto argAsDecl = arg->var.as<ast::ObjectDecl>();
    239     if (argAsDecl->type.as<ast::EnumInstType>()) {
    240         ast::Pass<ReplaceEnumInstWithPos> replacer;
    241         auto rep = argAsDecl->accept(replacer);
    242         auto mutatedArg = ast::mutate_field(arg, &ast::VariableExpr::var, rep);
    243         mutatedArg = ast::mutate_field(mutatedArg, &ast::VariableExpr::result,
    244                                        mutatedArg->var->get_type());
    245         auto untyped =
    246             new ast::UntypedExpr(location, new ast::NameExpr(location, "?[?]"),
    247                                  {std::move(arrAsVar), mutatedArg});
    248         auto typedResult = ResolvExpr::findVoidExpression(untyped, context);
    249         ast::ptr<ast::ApplicationExpr> ret =
    250             typedResult.strict_as<ast::ApplicationExpr>();
    251         return ast::deepCopy(ret);
    252     } else {
    253         auto untyped =
    254             new ast::UntypedExpr(location, new ast::NameExpr(location, "?[?]"),
    255                                  {std::move(arrAsVar), arg});
    256         auto typedResult = ResolvExpr::findVoidExpression(untyped, context);
    257 
    258         ast::ptr<ast::ApplicationExpr> ret =
    259             typedResult.strict_as<ast::ApplicationExpr>();
    260         return ast::deepCopy(ret);
    261     }
    262 }
    263 
    264 ast::Expr const* ReplacePseudoFuncCore::postvisit(
    265     ast::ApplicationExpr const* expr) {
    266     auto fname = ast::getFunctionName(expr);
    267     auto location = expr->location;
    268     if (fname == "posE" || fname == "valueE" || fname == "labelE") {
    269         if (expr->args.size() != 1) {
    270             SemanticError(expr,
    271                           "Pseudo Enum Expression only take one parameter");
    272         }
    273         ast::ptr<ast::VariableExpr> arg =
    274             expr->args.front().as<const ast::VariableExpr>();
    275         if (!arg) {
    276             SemanticError(expr, "Unimplement Pseudo Function Cases");
    277         }
    278         const ast::ObjectDecl* argAsVar = arg->var.as<const ast::ObjectDecl>();
    279         const std::string referredName = argAsVar->name;
    280 
    281         if (const ast::EnumInstType* argTypeAsEnumInst =
    282                 argAsVar->type.as<const ast::EnumInstType>()) {
    283             const ast::EnumDecl* base = argTypeAsEnumInst->base;
    284             ResolvExpr::ResolveContext context{symtab, transUnit().global};
    285             // If resolvable as constant
    286             for (size_t i = 0; i < base->members.size(); i++) {
    287                 if (base->members[i]->name == referredName) {
    288                     if (fname == "posE")
    289                         return ast::ConstantExpr::from_int(expr->location, i);
    290                     else if (fname == "labelE")
    291                         return ast::ConstantExpr::from_string(expr->location,
    292                                                               referredName);
    293                     else {
    294                         return resolveAttributeFunctions(
    295                             location, context, arg.get(), base, "values_");
    296                     }
    297                 }
    298             }
    299 
    300             if (fname == "labelE") {
    301                 if (auto labelExpr = resolveAttributeFunctions(
    302                         location, context, arg.get(), base, "labels_")) {
    303                     return labelExpr;
    304                 }
    305             } else if (fname == "valueE") {
    306                 if (auto valueExpr = resolveAttributeFunctions(
    307                         location, context, arg.get(), base, "values_")) {
    308                     return valueExpr;
    309                 }
    310             } else {  // it is position; replace itself
    311                 return std::move(arg.get());
    312             }
    313         } else if (const ast::EnumPosType* argTypeAsPos =
    314                        argAsVar->type.as<const ast::EnumPosType>()) {
    315             const ast::EnumDecl* base = argTypeAsPos->instance->base;
    316             ResolvExpr::ResolveContext context{symtab, transUnit().global};
    317             if (fname == "labelE") {
    318                 if (auto labelExpr = resolveAttributeFunctions(
    319                         location, context, arg.get(), base, "labels_")) {
    320                     return labelExpr;
    321                 }
    322             } else if (fname == "valueE") {
    323                 if (auto valueExpr = resolveAttributeFunctions(
    324                         location, context, arg.get(), base, "values_")) {
    325                     return valueExpr;
    326                 }
    327             } else {  // it is position; replace itself
    328                 return std::move(arg.get());
    329             }
    330         } else {
    331             SemanticError(argAsVar,
    332                           "Pseudo Enum Expression can only be used on an "
    333                           "enumeration instance");
    334         }
    335     }
    336     return expr;
    337 }
    33818
    33919ast::ptr<ast::Expr> reduceCastExpr(ast::ptr<ast::Expr> expr) {
    … …  
    35737                    if (auto enumInst =
    35838                            argAsDecl->type.as<ast::EnumInstType>()) {
    359                         auto castTo = new ast::EnumPosType(enumInst);
     39                        auto castTo = new ast::EnumAttrType(
     40                            enumInst, ast::EnumAttribute::Posn);
    36041                        auto castExpr =
    36142                            new ast::CastExpr(param->location, param, castTo);
    … …  
    37455                            typedResult.strict_as<ast::ApplicationExpr>();
    37556                        return ast::deepCopy(ret);
    376                     } else if (auto posType =
    377                                    argAsDecl->type.as<ast::EnumPosType>()) {
    378                         // Very nasty fix. Must be revisit
    379                         if (auto paramAsVar = param.as<ast::VariableExpr>()) {
    380                             if (paramAsVar->result.as<ast::EnumInstType>()) {
    381                                 auto paramToUse = ast::mutate_field(
    382                                     paramAsVar, &ast::VariableExpr::result,
    383                                     posType);
    384                                 auto untyped = new ast::UntypedExpr(
    385                                     expr->location,
    386                                     new ast::NameExpr(location,
    387                                                       fname == "succ"
    388                                                           ? "_successor_"
    389                                                           : "_predessor_"),
    390                                     {paramToUse});
    391                                 ResolvExpr::ResolveContext context{
    392                                     symtab, transUnit().global};
    393                                 auto typedResult =
    394                                     ResolvExpr::findVoidExpression(untyped,
    395                                                                    context);
    396                                 ast::ptr<ast::ApplicationExpr> ret =
    397                                     typedResult
    398                                         .strict_as<ast::ApplicationExpr>();
    399                                 return ast::deepCopy(ret);
    400                             }
    401                         }
    402                         auto untyped = new ast::UntypedExpr(
    403                             expr->location,
    404                             new ast::NameExpr(location, fname == "succ"
    405                                                             ? "_successor_"
    406                                                             : "_predessor_"),
    407                             {param});
    408                         ResolvExpr::ResolveContext context{symtab,
    409                                                            transUnit().global};
    410                         auto typedResult =
    411                             ResolvExpr::findVoidExpression(untyped, context);
    412                         ast::ptr<ast::ApplicationExpr> ret =
    413                             typedResult.strict_as<ast::ApplicationExpr>();
    414                         return ast::deepCopy(ret);
     57                    } else if (argAsDecl->type.as<ast::EnumAttrType>()) {
     58                        std::cerr << "PseudoFunc: succ/pred should not be applied on EnumAttrType directly" << std::endl;
    41559                    }
    41660                }
    … …  
    42468
    42569void replacePseudoFunc(ast::TranslationUnit& translationUnit) {
    426     ast::Pass<WrapEnumValueExpr>::run(translationUnit);
    427     ast::Pass<FindGenEnumArray>::run(translationUnit);
    428 
    429     ast::Pass<PseudoFuncGenerateRoutine>::run(translationUnit);
    430     ast::Pass<ReplacePseudoFuncCore>::run(translationUnit);
    431 
    43270    ast::Pass<ReplaceSuccAndPred>::run(translationUnit);
    43371}

  • src/Validate/ReplaceTypedef.cpp

    rda87eaf r4e08a54  
    349349                // Perhaps this should be a warning instead.
    350350                translationUnit.global.sizeType =
    351                         new ast::BasicType( ast::BasicType::LongUnsignedInt );
     351                        new ast::BasicType( ast::BasicKind::LongUnsignedInt );
    352352        }
    353353}

  • src/Validate/module.mk

    rda87eaf r4e08a54  
    5454        Validate/VerifyCtorDtorAssign.hpp \
    5555        Validate/ReplacePseudoFunc.cpp \
    56         Validate/ReplacePseudoFunc.hpp
     56        Validate/ReplacePseudoFunc.hpp \
     57        Validate/ImplementEnumFunc.cpp \
     58        Validate/ImplementEnumFunc.hpp
    5759
    5860SRCDEMANGLE += $(SRC_VALIDATE)

  • src/main.cc

    rda87eaf r4e08a54  
    6666#include "Tuples/Tuples.h"                  // for expandMemberTuples, expan...
    6767#include "Validate/Autogen.hpp"             // for autogenerateRoutines
    68 // #include "Validate/ImplementEnumFunc.hpp"   // for implementEnumFunc
     68#include "Validate/ImplementEnumFunc.hpp"   // for implementEnumFunc
    6969#include "Validate/CompoundLiteral.hpp"     // for handleCompoundLiterals
    7070#include "Validate/EliminateTypedef.hpp"    // for eliminateTypedef
    … …  
    333333
    334334                PASS( "Generate Autogen Routines", Validate::autogenerateRoutines, transUnit );
    335                 // PASS( "Generate Enum Attributes Functions", Validate::implementEnumFunc, transUnit );
     335                PASS( "Generate Enum Attributes Functions", Validate::implementEnumFunc, transUnit );
    336336
    337337                PASS( "Implement Actors", Concurrency::implementActors, transUnit );
    … …  
    382382                DUMP( exprp, std::move( transUnit ) );
    383383                PASS( "Replace Pseudo Func", Validate::replacePseudoFunc, transUnit );
    384                 DUMP( reppseu, std::move( transUnit ) );
    385                 PASS( "Fix Init", InitTweak::fix, transUnit, buildingLibrary() );
     384                PASS( "Fix Init", InitTweak::fix, transUnit, buildingLibrary() ); // Here
    386385                PASS( "Erase With", ResolvExpr::eraseWith, transUnit );
    387386
    … …  
    534533        { "instgen", genericsp, true, "print AST after instantiate generics" },
    535534        { "bbox", bboxp, true, "print AST before box pass" },
    536         { "bcodegen", bcodegenp, true, "print AST before code generation" },
    537         { "reppseu", reppseu, true, "print AST after replacing pseudo functions" }
     535        { "bcodegen", bcodegenp, true, "print AST before code generation" }
    538536};
    539537enum { printoptsSize = sizeof( printopts ) / sizeof( printopts[0] ) };
Note: See TracChangeset for help on using the changeset viewer.