Changeset b0d9ff7


Ignore:
Timestamp:
Sep 1, 2022, 1:27:52 PM (5 months ago)
Author:
JiadaL <j82liang@…>
Branches:
master, pthread-emulation, qualifiedEnum
Children:
12df6fe
Parents:
def751f
Message:

Fix up the QualifiedNameExpr?. It should now work on both old AST and new AST. There are some known bugs to fix so make all-tests will fail.

Location:
src
Files:
32 edited

Legend:

Unmodified
Added
Removed
  • src/AST/Convert.cpp

    rdef751f rb0d9ff7  
    310310                        node->name,
    311311                        get<Attribute>().acceptL( node->attributes ),
     312                        false, // Temporary
    312313                        LinkageSpec::Spec( node->linkage.val ),
    313314                        get<Type>().accept1(node->base)
     
    731732        }
    732733
     734        const ast::Expr * visit( const ast::QualifiedNameExpr * node ) override final {
     735                auto temp = new QualifiedNameExpr(
     736                                get<Declaration>().accept1(node->type_decl),
     737                                node->name
     738                );
     739                temp->var = get<DeclarationWithType>().accept1(node->var);
     740                auto expr = visitBaseExpr( node,
     741                        temp
     742                );
     743                this->node = expr;
     744                return nullptr;
     745        }
     746
    733747        const ast::Expr * visit( const ast::AddressExpr * node ) override final {
    734748                auto expr = visitBaseExpr( node,
     
    17401754                        old->location,
    17411755                        old->name,
     1756                        old->isTyped,
    17421757                        GET_ACCEPT_V(attributes, Attribute),
    17431758                        { old->linkage.val },
     
    22662281        }
    22672282
     2283        /// xxx - type_decl should be DeclWithType in the final design
     2284        /// type_decl is set to EnumDecl as a temporary fix
     2285        virtual void visit( const QualifiedNameExpr * old ) override final {
     2286                this->node = visitBaseExpr( old,
     2287                        new ast::QualifiedNameExpr (
     2288                                old->location,
     2289                                GET_ACCEPT_1(type_decl, Decl),
     2290                                GET_ACCEPT_1(var, DeclWithType),
     2291                                old->name
     2292                        )
     2293                );
     2294        }
     2295
    22682296        virtual void visit( const CastExpr * old ) override final {
    22692297                this->node = visitBaseExpr( old,
  • src/AST/Decl.hpp

    rdef751f rb0d9ff7  
    312312class EnumDecl final : public AggregateDecl {
    313313public:
     314        bool isTyped;
    314315        ptr<Type> base;
    315316
    316         EnumDecl( const CodeLocation& loc, const std::string& name,
    317                 std::vector<ptr<Attribute>>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall, Type const * base = nullptr,
     317        EnumDecl( const CodeLocation& loc, const std::string& name, bool isTyped = false,
     318                std::vector<ptr<Attribute>>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall,
     319                Type const * base = nullptr,
    318320                std::unordered_map< std::string, long long > enumValues = std::unordered_map< std::string, long long >() )
    319         : AggregateDecl( loc, name, std::move(attrs), linkage ), base(base), enumValues(enumValues) {}
     321        : AggregateDecl( loc, name, std::move(attrs), linkage ), isTyped(isTyped), base(base), enumValues(enumValues) {}
    320322
    321323        /// gets the integer value for this enumerator, returning true iff value found
     
    327329        const char * typeString() const override { return aggrString( Enum ); }
    328330
    329         bool isTyped() {return base && base.get();}
    330331
    331332private:
  • src/AST/Expr.hpp

    rdef751f rb0d9ff7  
    254254};
    255255
     256class QualifiedNameExpr final : public Expr {
     257public:
     258        ptr<Decl> type_decl;
     259        ptr<DeclWithType> var;
     260        std::string name;
     261
     262        QualifiedNameExpr( const CodeLocation & loc, const Decl * d, const DeclWithType * r, const std::string & n )
     263        : Expr( loc ), type_decl( d ), var(r), name( n ) {}
     264
     265        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
     266private:
     267        QualifiedNameExpr * clone() const override { return new QualifiedNameExpr{ *this }; }
     268        MUTATE_FRIEND
     269};
     270
    256271/// A reference to a named variable.
    257272class VariableExpr final : public Expr {
  • src/AST/Fwd.hpp

    rdef751f rb0d9ff7  
    6767class UntypedExpr;
    6868class NameExpr;
     69class QualifiedNameExpr;
    6970class AddressExpr;
    7071class LabelAddressExpr;
  • src/AST/Pass.hpp

    rdef751f rb0d9ff7  
    167167        const ast::Expr *             visit( const ast::UntypedExpr          * ) override final;
    168168        const ast::Expr *             visit( const ast::NameExpr             * ) override final;
     169        const ast::Expr *                         visit( const ast::QualifiedNameExpr    * ) override final;
    169170        const ast::Expr *             visit( const ast::AddressExpr          * ) override final;
    170171        const ast::Expr *             visit( const ast::LabelAddressExpr     * ) override final;
  • src/AST/Pass.impl.hpp

    rdef751f rb0d9ff7  
    11931193
    11941194//--------------------------------------------------------------------------
     1195// QualifiedNameExpr
     1196template< typename core_t >
     1197const ast::Expr * ast::Pass< core_t >::visit( const ast::QualifiedNameExpr * node ) {
     1198        VISIT_START( node );
     1199        if ( __visit_children() ) {
     1200                guard_symtab guard { *this };
     1201                maybe_accept( node, &QualifiedNameExpr::var );
     1202                maybe_accept( node, &QualifiedNameExpr::type_decl );
     1203        }
     1204        VISIT_END( Expr, node );
     1205}
     1206
     1207//--------------------------------------------------------------------------
    11951208// CastExpr
    11961209template< typename core_t >
  • src/AST/Print.cpp

    rdef751f rb0d9ff7  
    899899                postprint( node );
    900900
     901                return node;
     902        }
     903
     904        virtual const ast::Expr * visit( const ast::QualifiedNameExpr * node ) override final {
     905                os << "QualifiedNameExpr: " << std::endl;
     906                os << ++indent << "Type: ";
     907                safe_print( node->type_decl );
     908                os << std::endl;
     909                os <<  indent << "Name: " << node->name  << std::endl;
     910                --indent;
     911                postprint( node );
    901912                return node;
    902913        }
  • src/AST/Visitor.hpp

    rdef751f rb0d9ff7  
    5959    virtual const ast::Expr *             visit( const ast::UntypedExpr          * ) = 0;
    6060    virtual const ast::Expr *             visit( const ast::NameExpr             * ) = 0;
     61    virtual const ast::Expr *             visit( const ast::QualifiedNameExpr    * ) = 0;
    6162    virtual const ast::Expr *             visit( const ast::AddressExpr          * ) = 0;
    6263    virtual const ast::Expr *             visit( const ast::LabelAddressExpr     * ) = 0;
  • src/CodeGen/CodeGenerator.cc

    rdef751f rb0d9ff7  
    689689                        output << opInfo->symbol;
    690690                } else {
    691                         // if (dynamic_cast<EnumInstType *>(variableExpr->get_var()->get_type())
    692                         // && dynamic_cast<EnumInstType *>(variableExpr->get_var()->get_type())->baseEnum->base) {
    693                         //      output << '(' <<genType(dynamic_cast<EnumInstType *>(variableExpr->get_var()->get_type())->baseEnum->base, "", options) << ')';
    694                         // }
    695691                        output << mangleName( variableExpr->get_var() );
    696692                } // if
     
    911907        }
    912908
     909        // QualifiedNameExpr should not reach to CodeGen.
     910        // FixQualifiedName Convert QualifiedNameExpr to VariableExpr
     911        void CodeGenerator::postvisit( QualifiedNameExpr * expr ) {
     912                output << "/* label */" << mangleName(expr->var);
     913        }
    913914
    914915        // *** Statements
  • src/CodeGen/CodeGenerator.h

    rdef751f rb0d9ff7  
    103103                void postvisit( DefaultArgExpr * );
    104104                void postvisit( GenericExpr * );
     105                void postvisit( QualifiedNameExpr *);
    105106
    106107                //*** Statements
  • src/Common/CodeLocationTools.cpp

    rdef751f rb0d9ff7  
    137137    macro(UntypedExpr, Expr) \
    138138    macro(NameExpr, Expr) \
     139        macro(QualifiedNameExpr, Expr) \
    139140    macro(AddressExpr, Expr) \
    140141    macro(LabelAddressExpr, Expr) \
  • src/Common/PassVisitor.h

    rdef751f rb0d9ff7  
    133133        virtual void visit( NameExpr * nameExpr ) override final;
    134134        virtual void visit( const NameExpr * nameExpr ) override final;
     135        virtual void visit ( QualifiedNameExpr * qualifiedNameExpr ) override final;
     136        virtual void visit ( const QualifiedNameExpr * qualifiedNameExpr ) override final;
    135137        virtual void visit( CastExpr * castExpr ) override final;
    136138        virtual void visit( const CastExpr * castExpr ) override final;
     
    325327        virtual Expression * mutate( TupleExpr * tupleExpr ) override final;
    326328        virtual Expression * mutate( TupleIndexExpr * tupleExpr ) override final;
    327         virtual Expression * mutate( TupleAssignExpr * assignExpr ) override final;
     329        virtual Expression * mutate( TupleAssignExpr * assignExpr ) override final; 
    328330        virtual Expression * mutate( StmtExpr *  stmtExpr ) override final;
    329331        virtual Expression * mutate( UniqueExpr *  uniqueExpr ) override final;
     
    333335        virtual Expression * mutate( DefaultArgExpr * argExpr ) override final;
    334336        virtual Expression * mutate( GenericExpr * genExpr ) override final;
     337        virtual Expression * mutate( QualifiedNameExpr * qualifiedNameExpr ) override final;
    335338
    336339        virtual Type * mutate( VoidType * basicType ) override final;
  • src/Common/PassVisitor.impl.h

    rdef751f rb0d9ff7  
    19271927
    19281928//--------------------------------------------------------------------------
     1929// QualifiedNameExpr
     1930template< typename pass_type >
     1931void PassVisitor< pass_type >::visit( QualifiedNameExpr * node ) {
     1932        VISIT_START( node );
     1933
     1934        indexerScopedAccept( node->result, *this );
     1935        maybeAccept_impl( node->type_decl, *this );
     1936        maybeAccept_impl( node->var, *this );
     1937
     1938        VISIT_END( node );
     1939}
     1940
     1941template< typename pass_type >
     1942void PassVisitor< pass_type >::visit( const QualifiedNameExpr * node ) {
     1943        VISIT_START( node );
     1944
     1945        indexerScopedAccept( node->result, *this );
     1946        maybeAccept_impl( node->type_decl, *this );
     1947        maybeAccept_impl( node->var, *this );
     1948
     1949        VISIT_END( node );
     1950}
     1951
     1952template< typename pass_type >
     1953Expression * PassVisitor< pass_type >::mutate( QualifiedNameExpr * node ) {
     1954        MUTATE_START( node );
     1955
     1956    indexerScopedMutate( node->env   , *this );
     1957    indexerScopedMutate( node->result, *this );
     1958        maybeMutate_impl( node->type_decl, *this );
     1959        maybeAccept_impl( node->var, *this );
     1960
     1961        MUTATE_END( Expression, node );
     1962}
     1963
     1964//--------------------------------------------------------------------------
    19291965// CastExpr
    19301966template< typename pass_type >
  • src/Parser/DeclarationNode.cc

    rdef751f rb0d9ff7  
    253253} // DeclarationNode::newAggregate
    254254
    255 DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body, DeclarationNode * base) {
     255DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body, bool typed, DeclarationNode * base) {
    256256        DeclarationNode * newnode = new DeclarationNode;
    257257        newnode->type = new TypeData( TypeData::Enum );
     
    260260        newnode->type->enumeration.body = body;
    261261        newnode->type->enumeration.anon = name == nullptr;
     262        newnode->type->enumeration.typed = typed;
    262263        if ( base && base->type)  {
    263264                newnode->type->base = base->type;       
    264265        } // if
    265266
    266         // Check: if base has TypeData
    267267        return newnode;
    268268} // DeclarationNode::newEnum
     
    284284
    285285DeclarationNode * DeclarationNode::newEnumValueGeneric( const string * name, InitializerNode * init ) {
    286         if ( init ) { // list init {} or a singleInit
    287                 if ( init->get_expression() ) { // singleInit
     286        if ( init ) {
     287                if ( init->get_expression() ) {
    288288                        return newEnumConstant( name, init->get_expression() );
    289                 } else { // TODO: listInit
     289                } else {
    290290                        DeclarationNode * newnode = newName( name );
    291291                        newnode->initializer = init;
     
    293293                } // if
    294294        } else {
    295                 return newName( name ); // Not explicitly inited enum value;
     295                return newName( name );
    296296        } // if
    297297} // DeclarationNode::newEnumValueGeneric
  • src/Parser/ExpressionNode.cc

    rdef751f rb0d9ff7  
    510510
    511511QualifiedNameExpr * build_qualified_expr( const DeclarationNode * decl_node, const NameExpr * name ) {
    512         Type * targetType = maybeMoveBuildType( decl_node );
    513         return new QualifiedNameExpr( targetType, name->name );
    514         return nullptr;
     512        Declaration * newDecl = maybeBuild< Declaration >(decl_node);
     513        if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) {
     514                const Type * t = newDeclWithType->get_type();
     515                if ( t ) {
     516                        if ( const TypeInstType * typeInst = dynamic_cast<const TypeInstType *>( t ) ) {
     517                                newDecl= new EnumDecl( typeInst->name );
     518                        }
     519                }
     520        }
     521        auto ret =  new QualifiedNameExpr( newDecl, name->name );
     522        if ( auto e = dynamic_cast<EnumDecl*>(newDecl) ) {
     523                auto enumInst = new EnumInstType( Type::Qualifiers(), e );
     524                auto obj = new ObjectDecl( name->name, Type::StorageClasses(), LinkageSpec::Cforall, nullptr, enumInst, nullptr );
     525                ret->set_var( obj );
     526        }
     527        return ret;
     528}
     529
     530QualifiedNameExpr * build_qualified_expr( const EnumDecl * decl_node, const NameExpr * name ) {
     531        EnumDecl * newDecl = const_cast< EnumDecl * >( decl_node );
     532        return new QualifiedNameExpr( newDecl, name->name );
    515533}
    516534
  • src/Parser/ParseNode.h

    rdef751f rb0d9ff7  
    184184NameExpr * build_varref( const std::string * name );
    185185QualifiedNameExpr * build_qualified_expr( const DeclarationNode * decl_node, const NameExpr * name );
     186QualifiedNameExpr * build_qualified_expr( const EnumDecl * decl, const NameExpr * name );
    186187DimensionExpr * build_dimensionref( const std::string * name );
    187188
     
    236237        static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );
    237238        static DeclarationNode * newAggregate( AggregateDecl::Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
    238         static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, DeclarationNode * base = nullptr );
     239        static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed, DeclarationNode * base = nullptr );
    239240        static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant );
    240241        static DeclarationNode * newEnumValueGeneric( const std::string * name, InitializerNode * init );
  • src/Parser/TypeData.cc

    rdef751f rb0d9ff7  
    548548                return buildAggInst( td );
    549549          case TypeData::EnumConstant:
    550                 // the name gets filled in later -- by SymTab::Validate
    551550                return new EnumInstType( buildQualifiers( td ), "" );
    552551          case TypeData::SymbolicInst:
     
    923922        assert( td->kind == TypeData::Enum );
    924923        Type * baseType = td->base ? typebuild(td->base) : nullptr;
    925         EnumDecl * ret = new EnumDecl( *td->enumeration.name, attributes, linkage, baseType );
     924        EnumDecl * ret = new EnumDecl( *td->enumeration.name, attributes, td->enumeration.typed, linkage, baseType );
    926925        buildList( td->enumeration.constants, ret->get_members() );
    927926        list< Declaration * >::iterator members = ret->get_members().begin();
    928927        for ( const DeclarationNode * cur = td->enumeration.constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) {
    929                 if ( cur->has_enumeratorValue() ) {
     928                if ( ret->isTyped && cur->has_enumeratorValue() ) {
     929                        SemanticError( td->location, "Enumerator of enum(void) cannot have an explicit initializer value." );
     930                } else if ( cur->has_enumeratorValue() ) {
    930931                        ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members);
    931932                        member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ) ) );
    932933                } else if ( !cur->initializer ) {
    933934                        if ( baseType && (!dynamic_cast<BasicType *>(baseType) || !dynamic_cast<BasicType *>(baseType)->isWholeNumber())) {
    934                                 SemanticError( td->location, "A non whole number enum value decl must be explicitly initialized." );
     935                                SemanticError( td->location, "Enumerators of an non-integer typed enum must be explicitly initialized." );
    935936                        }
    936937                }
  • src/Parser/TypeData.h

    rdef751f rb0d9ff7  
    5959                bool body;
    6060                bool anon;
     61                bool typed;
    6162        };
    6263
  • src/Parser/parser.yy

    rdef751f rb0d9ff7  
    614614                { $$ = new ExpressionNode( new StmtExpr( dynamic_cast<CompoundStmt *>(maybeMoveBuild<Statement>($2) ) ) ); }
    615615        | type_name '.' identifier                                                      // CFA, nested type
    616                 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
     616                { $$ = new ExpressionNode( build_qualified_expr( $1, build_varref( $3 ) ) ); }
    617617        | type_name '.' '[' field_name_list ']'                         // CFA, nested type / tuple field selector
    618618                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
     
    23872387enum_type:
    23882388        ENUM attribute_list_opt '{' enumerator_list comma_opt '}'
    2389                 { $$ = DeclarationNode::newEnum( nullptr, $4, true )->addQualifiers( $2 ); }
     2389                { $$ = DeclarationNode::newEnum( nullptr, $4, true, false )->addQualifiers( $2 ); }
    23902390        | ENUM attribute_list_opt identifier
    23912391                { typedefTable.makeTypedef( *$3 ); }
    23922392          '{' enumerator_list comma_opt '}'
    2393                 { $$ = DeclarationNode::newEnum( $3, $6, true )->addQualifiers( $2 ); }
     2393                { $$ = DeclarationNode::newEnum( $3, $6, true, false )->addQualifiers( $2 ); }
    23942394        | ENUM attribute_list_opt typedef_name                          // unqualified type name
    23952395          '{' enumerator_list comma_opt '}'
    2396                 { $$ = DeclarationNode::newEnum( $3->name, $5, true )->addQualifiers( $2 ); }
     2396                { $$ = DeclarationNode::newEnum( $3->name, $5, true, false )->addQualifiers( $2 ); }
    23972397        | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '{' enumerator_list comma_opt '}'
    23982398                {
     
    24002400                        { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
    24012401
    2402                         $$ = DeclarationNode::newEnum( nullptr, $7, true, $3 )->addQualifiers( $5 );
     2402                        $$ = DeclarationNode::newEnum( nullptr, $7, true, true, $3 )->addQualifiers( $5 );
     2403                }
     2404        | ENUM '(' ')' attribute_list_opt '{' enumerator_list comma_opt '}'
     2405                {
     2406                        $$ = DeclarationNode::newEnum( nullptr, $6, true, true )->addQualifiers( $4 );
    24032407                }
    24042408        | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt
     
    24092413          '{' enumerator_list comma_opt '}'
    24102414                {
    2411                         $$ = DeclarationNode::newEnum( $6, $10, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 );
    2412                 }
     2415                        $$ = DeclarationNode::newEnum( $6, $10, true, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 );
     2416                }
     2417        | ENUM '(' ')' attribute_list_opt identifier attribute_list_opt
     2418          '{' enumerator_list comma_opt '}'
     2419                {
     2420                        $$ = DeclarationNode::newEnum( $5, $8, true, true, nullptr )->addQualifiers( $4 )->addQualifiers( $6 );
     2421                }       
    24132422        | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt typedef_name attribute_list_opt '{' enumerator_list comma_opt '}'
    24142423                {
    2415                         if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
    2416                         typedefTable.makeTypedef( *$6->name );
    2417                         $$ = DeclarationNode::newEnum( $6->name, $9, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 );
     2424                        $$ = DeclarationNode::newEnum( $6->name, $9, true, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 );
     2425                }
     2426        | ENUM '(' ')' attribute_list_opt typedef_name attribute_list_opt '{' enumerator_list comma_opt '}'
     2427                {
     2428                        $$ = DeclarationNode::newEnum( $5->name, $8, true, true, nullptr )->addQualifiers( $4 )->addQualifiers( $6 );
    24182429                }
    24192430        | enum_type_nobody
     
    24222433enum_type_nobody:                                                                               // enum - {...}
    24232434        ENUM attribute_list_opt identifier
    2424                 { typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, 0, false )->addQualifiers( $2 ); }
    2425         | ENUM attribute_list_opt type_name                                     // qualified type name
    2426                 { typedefTable.makeTypedef( *$3->type->symbolic.name ); $$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false )->addQualifiers( $2 ); }
     2435                { typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, 0, false, false )->addQualifiers( $2 ); }
     2436        | ENUM attribute_list_opt type_name     
     2437                { typedefTable.makeTypedef( *$3->type->symbolic.name ); $$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false, false )->addQualifiers( $2 ); }
    24272438        ;
    24282439
  • src/ResolvExpr/CandidateFinder.cpp

    rdef751f rb0d9ff7  
    862862                                }
    863863                        }
     864                }
     865
     866                void postvisit( const ast::QualifiedNameExpr * qualifiedNameExpr ) {
     867                        auto mangleName = Mangle::mangle(qualifiedNameExpr->var);
     868                        addCandidate( qualifiedNameExpr, tenv );
    864869                }
    865870
  • src/ResolvExpr/ConversionCost.cc

    rdef751f rb0d9ff7  
    338338                } else if ( const EnumInstType * enumInst = dynamic_cast< const EnumInstType * >( dest ) ) {
    339339                        const EnumDecl * base_enum = enumInst->baseEnum;
    340                         if ( const Type * base = base_enum->base ) { // if the base enum has a base (if it is typed)
     340                        if ( const Type * base = base_enum->base ) {
    341341                                if ( const BasicType * enumBaseAstBasic = dynamic_cast< const BasicType *> (base) ) {
    342342                                        conversionCostFromBasicToBasic(basicType, enumBaseAstBasic);
     
    632632        } else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
    633633                const ast::EnumDecl * enumDecl = enumInst->base.get();
    634                 if ( const ast::Type * enumType = enumDecl->base.get() ) {
     634                if ( enumDecl->isTyped && !enumDecl->base.get() ) {
     635                        cost = Cost::infinity;
     636                } else if ( const ast::Type * enumType = enumDecl->base.get() ) {
    635637                        if ( const ast::BasicType * enumTypeAsBasic = dynamic_cast<const ast::BasicType *>(enumType) ) {
    636638                                conversionCostFromBasicToBasic( basicType, enumTypeAsBasic );
     
    694696        const ast::EnumDecl * baseEnum = enumInstType->base;
    695697        if ( const ast::Type * baseType = baseEnum->base ) {
    696                 cost = costCalc( baseType, dst, srcIsLvalue, symtab, env );
    697                 // cost = Cost::safe;
     698                costCalc( baseType, dst, srcIsLvalue, symtab, env );
    698699        } else {
    699700                (void)enumInstType;
  • src/SymTab/Mangler.cc

    rdef751f rb0d9ff7  
    6565                                void postvisit( const QualifiedType * qualType );
    6666
     67                                void postvisit( const QualifiedNameExpr * qualNameExpr );
     68
    6769                                std::string get_mangleName() { return mangleName; }
    6870                          private:
     
    305307                                        mangleName += Encoding::qualifiedTypeEnd;
    306308                                }
     309                        }
     310
     311                        void Mangler_old::postvisit( const QualifiedNameExpr * qual ) {
     312                                maybeAccept( qual->var, *visitor );
    307313                        }
    308314
     
    417423                        void postvisit( const ast::OneType * oneType );
    418424                        void postvisit( const ast::QualifiedType * qualType );
     425                        void postvisit( const ast::QualifiedNameExpr * qualNameExpr );
    419426
    420427                        std::string get_mangleName() { return mangleName; }
     
    645652                                mangleName += Encoding::qualifiedTypeEnd;
    646653                        }
     654                }
     655                void Mangler_new::postvisit( const ast::QualifiedNameExpr * qual ) {
     656                        maybeAccept( qual->var.get(), *visitor );
    647657                }
    648658
  • src/SymTab/Validate.cc

    rdef751f rb0d9ff7  
    857857                } else if ( UnionInstType * aggDecl = dynamic_cast< UnionInstType * >( designatorType ) ) {
    858858                        declsToAddBefore.push_back( new UnionDecl( aggDecl->name, noAttributes, tyDecl->linkage ) );
    859                 } else if ( EnumInstType * enumDecl = dynamic_cast< EnumInstType * >( designatorType ) ) {
     859                } else if ( EnumInstType * enumInst = dynamic_cast< EnumInstType * >( designatorType ) ) {
    860860                        // declsToAddBefore.push_back( new EnumDecl( enumDecl->name, noAttributes, tyDecl->linkage, enumDecl->baseEnum->base ) );
    861                         if (enumDecl->baseEnum) {
    862                                 declsToAddBefore.push_back( new EnumDecl( enumDecl->name, noAttributes, tyDecl->linkage, enumDecl->baseEnum->base ) );
     861                        if ( enumInst->baseEnum ) {
     862                                const EnumDecl * enumDecl = enumInst->baseEnum;
     863                                declsToAddBefore.push_back( new EnumDecl( enumDecl->name, noAttributes, enumDecl->isTyped, tyDecl->linkage, enumDecl->base ) );
    863864                        } else {
    864                                 declsToAddBefore.push_back( new EnumDecl( enumDecl->name, noAttributes, tyDecl->linkage ) );
     865                                declsToAddBefore.push_back( new EnumDecl( enumInst->name, noAttributes, tyDecl->linkage ) );
    865866                        }
    866867                } // if
  • src/SymTab/ValidateType.cc

    rdef751f rb0d9ff7  
    8282        void postvisit( QualifiedType * qualType );
    8383
     84        void postvisit( QualifiedNameExpr * qualExpr );
     85
    8486        void postvisit( EnumDecl * enumDecl );
    8587        void postvisit( StructDecl * structDecl );
     
    157159        // linking only makes sense for the 'oldest ancestor' of the qualified type
    158160        qualType->parent->accept( * visitor );
     161}
     162
     163void LinkReferenceToTypes_old::postvisit( QualifiedNameExpr * qualExpr ) {
     164        const EnumDecl * st = local_indexer->lookupEnum( qualExpr->type_decl->name );
     165        qualExpr->type_decl = const_cast<EnumDecl *>(st);
    159166}
    160167
  • src/SynTree/Declaration.h

    rdef751f rb0d9ff7  
    145145        virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
    146146
    147         // TODO: Move to the right place
    148147        void checkAssignedValue() const;
    149148};
     
    338337        typedef AggregateDecl Parent;
    339338  public:
     339        bool isTyped;
     340        Type * base;
     341
    340342        EnumDecl( const std::string & name,
    341343         const std::list< Attribute * > & attributes = std::list< class Attribute * >(),
    342           LinkageSpec::Spec linkage = LinkageSpec::Cforall,
    343           Type * baseType = nullptr ) : Parent( name, attributes, linkage ) , base( baseType ){}
    344         EnumDecl( const EnumDecl & other ) : Parent( other ), base( other.base ) {}
    345 
     344          bool isTyped = false, LinkageSpec::Spec linkage = LinkageSpec::Cforall,
     345          Type * baseType = nullptr )
     346          : Parent( name, attributes, linkage ),isTyped(isTyped), base( baseType ) {}
     347        EnumDecl( const EnumDecl & other )
     348          : Parent( other ), isTyped( other.isTyped), base( other.base ) {}
    346349        bool valueOf( Declaration * enumerator, long long int & value );
    347 
    348350        virtual EnumDecl * clone() const override { return new EnumDecl( *this ); }
    349351        virtual void accept( Visitor & v ) override { v.visit( this ); }
    350352        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    351353        virtual Declaration * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    352         Type * base;
    353         std::unordered_map< std::string, long long int > enumValues;
     354
     355        std::unordered_map< std::string, long long int > enumValues; // This attribute is unused
    354356        virtual void print( std::ostream & os, Indenter indent = {} ) const override final;
    355357  private:
  • src/SynTree/Expression.h

    rdef751f rb0d9ff7  
    166166class QualifiedNameExpr : public Expression {
    167167  public:
    168         Type * type; // Convert to [parent] QualifiedNameExpr
    169         std::string name; // Convert from NameExpr
    170 
    171         QualifiedNameExpr( Type * type, std::string name):
    172                 Expression(), type(type), name(name) {
    173                 std::cout << "Making QualifiedNameExpr" << std::endl;
    174                 print( std::cout );
    175         }
    176         QualifiedNameExpr( const QualifiedNameExpr & other): Expression(other), type(other.type), name(other.name) {
    177 
    178         }
     168        Declaration * type_decl;
     169        std::string name;
     170        DeclarationWithType * var;
     171
     172        QualifiedNameExpr( Declaration * decl, std::string name): Expression(), type_decl(decl), name(name) {}
     173        QualifiedNameExpr( const QualifiedNameExpr & other): Expression(other), type_decl(other.type_decl), name(other.name), var(other.var) {}
     174        DeclarationWithType * get_var() const { return var; }
     175        void set_var( DeclarationWithType * newValue ) { var = newValue; }
     176
    179177        virtual ~QualifiedNameExpr() {
    180                 delete type;
     178                delete var;
     179                delete type_decl;
    181180        }
    182181
     
    184183                return new QualifiedNameExpr( * this );
    185184        }
    186         virtual void accept( Visitor & v ) override { (void)v; }
    187         virtual void accept( Visitor & v ) const override { (void)v; }
    188         virtual Expression * acceptMutator( Mutator & m ) override { (void) m;return nullptr; }
     185        virtual void accept( Visitor & v ) override { v.visit(this); }
     186        virtual void accept( Visitor & v ) const override { v.visit(this); }
     187        virtual Expression * acceptMutator( Mutator & m ) override {
     188                return m.mutate( this );
     189        }
     190       
    189191        virtual void print( std::ostream & os, Indenter indent = {} ) const override {
    190                 type->print( os, indent );
    191                 std::cout << name << std::endl;
     192                type_decl->print( os, indent );
     193                os << name << std::endl;
    192194        }
    193195};
  • src/SynTree/Mutator.h

    rdef751f rb0d9ff7  
    9898        virtual Expression * mutate( DefaultArgExpr * argExpr ) = 0;
    9999        virtual Expression * mutate( GenericExpr * genExpr ) = 0;
     100        virtual Expression * mutate( QualifiedNameExpr * qualifiedNameExpr ) = 0;
    100101
    101102        virtual Type * mutate( VoidType * basicType ) = 0;
  • src/SynTree/Type.h

    rdef751f rb0d9ff7  
    342342        Type * parent;
    343343        Type * child;
    344 
    345344        QualifiedType( const Type::Qualifiers & tq, Type * parent, Type * child );
    346345        QualifiedType( const QualifiedType & tq );
  • src/SynTree/Visitor.h

    rdef751f rb0d9ff7  
    101101        virtual void visit( NameExpr * node ) { visit( const_cast<const NameExpr *>(node) ); }
    102102        virtual void visit( const NameExpr * nameExpr ) = 0;
     103        virtual void visit( QualifiedNameExpr * node ) { visit( const_cast<const QualifiedNameExpr*>(node) );}
     104        virtual void visit( const QualifiedNameExpr* qualifiednameExpr ) = 0;
    103105        virtual void visit( CastExpr * node ) { visit( const_cast<const CastExpr *>(node) ); }
    104106        virtual void visit( const CastExpr * castExpr ) = 0;
  • src/Validate/FixQualifiedTypes.cpp

    rdef751f rb0d9ff7  
    1919#include "AST/TranslationUnit.hpp"
    2020#include "Validate/NoIdSymbolTable.hpp"
     21#include "SymTab/Mangler.h"            // for Mangler
     22#include "AST/LinkageSpec.hpp"                     // for Linkage
    2123
    2224namespace Validate {
     
    8991                }
    9092        }
     93
     94        ast::Expr const * postvisit( ast::QualifiedNameExpr const * t) {
     95                assert( location );
     96                if ( t->type_decl ) {
     97                auto enumName = t->type_decl->name;
     98                const ast::EnumDecl * enumDecl = symtab.lookupEnum( enumName );
     99                        for ( ast::ptr<ast::Decl> const & member : enumDecl->members ) {
     100                                if ( auto memberAsObj = member.as<ast::ObjectDecl>() ) {
     101                                        if ( memberAsObj->name == t->name ) {
     102                                                return new ast::VariableExpr( t->location, memberAsObj );
     103                                        }
     104                                } else {
     105                                        assertf( false, "unhandled qualified child type");
     106                                }
     107                        }
     108
     109
     110                auto var = new ast::ObjectDecl( t->var->location, t->name,
     111                         new ast::EnumInstType(enumDecl, ast::CV::Const), nullptr, {}, ast::Linkage::Cforall );
     112                        var->scopeLevel = 1; // 1 for now; should copy the scopeLevel of the enumValue
     113                        var->mangleName = Mangle::mangle( var );
     114                        return new ast::VariableExpr( t->location, var );
     115                // return ret;
     116        }
     117
     118                return t;
     119        }
     120
    91121};
    92122
  • src/Validate/LinkReferenceToTypes.cpp

    rdef751f rb0d9ff7  
    4646        void postvisit( ast::UnionDecl const * decl );
    4747        ast::TraitDecl const * postvisit( ast::TraitDecl const * decl );
     48        ast::QualifiedNameExpr const * previsit( ast::QualifiedNameExpr const * decl);
    4849
    4950private:
     
    292293}
    293294
     295ast::QualifiedNameExpr const * LinkTypesCore::previsit( ast::QualifiedNameExpr const * decl ) {
     296        // Try to lookup type
     297        if ( auto objDecl = decl->type_decl.as<ast::ObjectDecl>() ) {
     298                if ( auto inst = objDecl->type.as<ast::TypeInstType>()) {
     299                        if ( auto enumDecl = symtab.lookupEnum ( inst->name ) ) {
     300                                auto mut = ast::mutate( decl );
     301                                mut->type_decl = enumDecl;
     302                                auto enumInst = new ast::EnumInstType( enumDecl );
     303                                enumInst->name = decl->name;
     304                                // Adding result; addCandidate() use result
     305                                mut->result = enumInst;
     306                                decl = mut;
     307                        }
     308                }
     309        } else if ( auto enumDecl = decl->type_decl.as<ast::EnumDecl>() ) {
     310                auto mut = ast::mutate( decl );
     311                auto enumInst = new ast::EnumInstType( enumDecl );
     312                enumInst->name = decl->name;
     313                // Adding result; addCandidate() use result
     314                mut->result = enumInst;
     315                decl = mut;
     316        }
     317        // ast::EnumDecl const * decl = symtab.lookupEnum( type->name );
     318        // // It's not a semantic error if the enum is not found, just an implicit forward declaration.
     319        // if ( decl ) {
     320        //      // Just linking in the node.
     321        //      auto mut = ast::mutate( type );
     322        //      mut->base = const_cast<ast::EnumDecl *>( decl );
     323        //      type = mut;
     324        // }
     325        return decl;
     326}
     327
    294328} // namespace
    295329
  • src/Validate/ReplaceTypedef.cpp

    rdef751f rb0d9ff7  
    183183        } else if ( auto enumType = dynamic_cast<ast::EnumInstType const *>( designatorType ) ) {
    184184                declsToAddBefore.push_back( new ast::EnumDecl(
    185                         decl->location, enumType->name, {}, decl->linkage,
     185                        decl->location, enumType->name, false, {}, decl->linkage,
    186186                        ( (enumType->base) ? enumType->base->base : nullptr )
    187187                        ) );
Note: See TracChangeset for help on using the changeset viewer.