Changes in / [c2b3243:ce7d197]


Ignore:
Location:
src
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • src/AST/Convert.cpp

    rc2b3243 rce7d197  
    310310                        node->name,
    311311                        get<Attribute>().acceptL( node->attributes ),
    312                         node->isTyped,
     312                        false, // Temporary
    313313                        LinkageSpec::Spec( node->linkage.val ),
    314314                        get<Type>().accept1(node->base)
    315315                );
    316                 return aggregatePostamble( decl, node );
     316                return aggregatePostamble( decl, node ); // Node info, including members, processed in aggregatePostamble
    317317        }
    318318
    … …  
    737737                                node->name
    738738                );
     739                temp->var = get<DeclarationWithType>().accept1(node->var);
    739740                auto expr = visitBaseExpr( node,
    740741                        temp
    … …  
    16141615                        { old->get_funcSpec().val }
    16151616                );
    1616                 decl->enumInLine = old->enumInLine;
    16171617                cache.emplace(old, decl);
    16181618                assert(cache.find( old ) != cache.end());
    … …  
    22812281        }
    22822282
     2283        /// xxx - type_decl should be DeclWithType in the final design
     2284        /// type_decl is set to EnumDecl as a temporary fix
    22832285        virtual void visit( const QualifiedNameExpr * old ) override final {
    22842286                this->node = visitBaseExpr( old,
    … …  
    22862288                                old->location,
    22872289                                GET_ACCEPT_1(type_decl, Decl),
     2290                                GET_ACCEPT_1(var, DeclWithType),
    22882291                                old->name
    22892292                        )

  • src/AST/Decl.hpp

    rc2b3243 rce7d197  
    105105        ptr<Init> init;
    106106        ptr<Expr> bitfieldWidth;
    107         bool enumInLine = false; // A flag vairable to tell the compile:
    108         // this is not a real object declaration. It is a place holder for
    109         // a set of enum value (ObjectDecl).
    110107
    111108        ObjectDecl( const CodeLocation & loc, const std::string & name, const Type * type,
    … …  
    315312class EnumDecl final : public AggregateDecl {
    316313public:
    317         bool isTyped; // isTyped indicated if the enum has a declaration like:
    318         // enum (type_optional) Name {...}
    319         ptr<Type> base; // if isTyped == true && base.get() == nullptr, it is a "void" type enum
     314        bool isTyped;
     315        ptr<Type> base;
    320316
    321317        EnumDecl( const CodeLocation& loc, const std::string& name, bool isTyped = false,

  • src/AST/Expr.hpp

    rc2b3243 rce7d197  
    257257public:
    258258        ptr<Decl> type_decl;
     259        ptr<DeclWithType> var;
    259260        std::string name;
    260261
    261         QualifiedNameExpr( const CodeLocation & loc, const Decl * d, const std::string & n )
    262         : Expr( loc ), type_decl( d ), name( n ) {}
     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 ) {}
    263264
    264265        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }

  • src/AST/Pass.impl.hpp

    rc2b3243 rce7d197  
    12051205        if ( __visit_children() ) {
    12061206                guard_symtab guard { *this };
     1207                maybe_accept( node, &QualifiedNameExpr::var );
    12071208                maybe_accept( node, &QualifiedNameExpr::type_decl );
    12081209        }

  • src/CodeGen/CodeGenerator.cc

    rc2b3243 rce7d197  
    912912                }
    913913                output << ")";
     914        }
     915
     916        // QualifiedNameExpr should not reach to CodeGen.
     917        // FixQualifiedName Convert QualifiedNameExpr to VariableExpr
     918        void CodeGenerator::postvisit( QualifiedNameExpr * expr ) {
     919                output << "/* label */" << mangleName(expr->var);
    914920        }
    915921

  • src/CodeGen/CodeGenerator.h

    rc2b3243 rce7d197  
    103103                void postvisit( DefaultArgExpr * );
    104104                void postvisit( GenericExpr * );
     105                void postvisit( QualifiedNameExpr *);
    105106
    106107                //*** Statements

  • src/Common/PassVisitor.impl.h

    rc2b3243 rce7d197  
    19341934        indexerScopedAccept( node->result, *this );
    19351935        maybeAccept_impl( node->type_decl, *this );
     1936        maybeAccept_impl( node->var, *this );
    19361937
    19371938        VISIT_END( node );
    … …  
    19441945        indexerScopedAccept( node->result, *this );
    19451946        maybeAccept_impl( node->type_decl, *this );
     1947        maybeAccept_impl( node->var, *this );
    19461948
    19471949        VISIT_END( node );
    … …  
    19551957    indexerScopedMutate( node->result, *this );
    19561958        maybeMutate_impl( node->type_decl, *this );
     1959        maybeAccept_impl( node->var, *this );
    19571960
    19581961        MUTATE_END( Expression, node );

  • src/Parser/DeclarationNode.cc

    rc2b3243 rce7d197  
    297297        } // if
    298298} // DeclarationNode::newEnumValueGeneric
    299 
    300 DeclarationNode * DeclarationNode::newEnumInLine( const string name ) {
    301         DeclarationNode * newnode = newName( new std::string(name) );
    302         newnode->enumInLine = true;
    303         return newnode;
    304 }
    305299
    306300DeclarationNode * DeclarationNode::newFromTypedef( const string * name ) {

  • src/Parser/ExpressionNode.cc

    rc2b3243 rce7d197  
    523523                auto enumInst = new EnumInstType( Type::Qualifiers(), e );
    524524                auto obj = new ObjectDecl( name->name, Type::StorageClasses(), LinkageSpec::Cforall, nullptr, enumInst, nullptr );
     525                ret->set_var( obj );
    525526        }
    526527        return ret;

  • src/Parser/ParseNode.h

    rc2b3243 rce7d197  
    240240        static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant );
    241241        static DeclarationNode * newEnumValueGeneric( const std::string * name, InitializerNode * init );
    242         static DeclarationNode * newEnumInLine( const std::string name );
    243242        static DeclarationNode * newName( const std::string * );
    244243        static DeclarationNode * newFromTypeGen( const std::string *, ExpressionNode * params );
    … …  
    340339
    341340        bool inLine = false;
    342         bool enumInLine = false;
    343341        Type::FuncSpecifiers funcSpecs;
    344342        Type::StorageClasses storageClasses;

  • src/Parser/TypeData.cc

    rc2b3243 rce7d197  
    924924        list< Declaration * >::iterator members = ret->get_members().begin();
    925925        for ( const DeclarationNode * cur = td->enumeration.constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) {
    926                 if ( cur->enumInLine ) {
    927                         // Tell the compiler this is a inline value placeholder
    928                         ObjectDecl * member = dynamic_cast< ObjectDecl* >(* members);
    929                         member->enumInLine = true;
    930                 }
    931926                if ( ret->isTyped && !ret->base && cur->has_enumeratorValue() ) {
    932927                        SemanticError( td->location, "Enumerator of enum(void) cannot have an explicit initializer value." );

  • src/Parser/parser.yy

    rc2b3243 rce7d197  
    26052605                { $$ = DeclarationNode::newEnumValueGeneric( $1, $2 ); }
    26062606        | INLINE type_name
    2607                 { $$ = DeclarationNode::newEnumInLine( *$2->type->symbolic.name ); }
     2607                { $$ = DeclarationNode::newEnumValueGeneric( new string("inline"), nullptr ); }
    26082608        | enumerator_list ',' identifier_or_type_name enumerator_value_opt
    26092609                { $$ = $1->appendList( DeclarationNode::newEnumValueGeneric( $3, $4 ) ); }

  • src/ResolvExpr/CandidateFinder.cpp

    rc2b3243 rce7d197  
    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/SymTab/Mangler.cc

    rc2b3243 rce7d197  
    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

    rc2b3243 rce7d197  
    858858                        declsToAddBefore.push_back( new UnionDecl( aggDecl->name, noAttributes, tyDecl->linkage ) );
    859859                } else if ( EnumInstType * enumInst = dynamic_cast< EnumInstType * >( designatorType ) ) {
     860                        // declsToAddBefore.push_back( new EnumDecl( enumDecl->name, noAttributes, tyDecl->linkage, enumDecl->baseEnum->base ) );
    860861                        if ( enumInst->baseEnum ) {
    861862                                const EnumDecl * enumDecl = enumInst->baseEnum;

  • src/SymTab/ValidateType.cc

    rc2b3243 rce7d197  
    8181        void previsit( QualifiedType * qualType );
    8282        void postvisit( QualifiedType * qualType );
     83
    8384        void postvisit( QualifiedNameExpr * qualExpr );
    84        
     85
    8586        void postvisit( EnumDecl * enumDecl );
    8687        void postvisit( StructDecl * structDecl );

  • src/SynTree/Declaration.h

    rc2b3243 rce7d197  
    121121        Initializer * init;
    122122        Expression * bitfieldWidth;
    123         bool enumInLine = false;
    124123
    125124        ObjectDecl( const std::string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Expression * bitfieldWidth, Type * type, Initializer * init,

  • src/SynTree/Expression.h

    rc2b3243 rce7d197  
    168168        Declaration * type_decl;
    169169        std::string name;
     170        DeclarationWithType * var;
    170171
    171172        QualifiedNameExpr( Declaration * decl, std::string name): Expression(), type_decl(decl), name(name) {}
    172         QualifiedNameExpr( const QualifiedNameExpr & other): Expression(other), type_decl(other.type_decl), name(other.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; }
    173176
    174177        virtual ~QualifiedNameExpr() {
     178                delete var;
    175179                delete type_decl;
    176180        }

  • src/Validate/FixQualifiedTypes.cpp

    rc2b3243 rce7d197  
    102102                        }
    103103
    104                 auto var = new ast::ObjectDecl( t->location, t->name,
    105                         new ast::EnumInstType(enumDecl, ast::CV::Const), nullptr, {}, ast::Linkage::Cforall );
     104
     105                auto var = new ast::ObjectDecl( t->var->location, t->name,
     106                         new ast::EnumInstType(enumDecl, ast::CV::Const), nullptr, {}, ast::Linkage::Cforall );
     107                        var->scopeLevel = 1; // 1 for now; should copy the scopeLevel of the enumValue
    106108                        var->mangleName = Mangle::mangle( var );
    107109                        return new ast::VariableExpr( t->location, var );
     110                // return ret;
    108111        }
    109112

  • src/Validate/LinkReferenceToTypes.cpp

    rc2b3243 rce7d197  
    4444        void postvisit( ast::UnionDecl const * decl );
    4545        ast::TraitDecl const * postvisit( ast::TraitDecl const * decl );
     46        ast::QualifiedNameExpr const * previsit( ast::QualifiedNameExpr const * decl);
    4647
    4748private:
    … …  
    202203        }
    203204
    204         // The following section
    205         auto mut = ast::mutate( decl );
    206         std::vector<ast::ptr<ast::Decl>> buffer;
    207         for ( auto it = decl->members.begin(); it != decl->members.end(); ++it) {
    208                 auto member = (*it).as<ast::ObjectDecl>();
    209                 if ( member->enumInLine ) {
    210                         auto targetEnum = symtab.lookupEnum( member->name );
    211                         if (targetEnum) {                       
    212                                 for (auto singleMamber : targetEnum->members) {
    213                                         auto tm = singleMamber.as<ast::ObjectDecl>();
    214                                         auto t = new ast::ObjectDecl(
    215                                                 member->location, // use the "inline" location
    216                                                 tm->name,
    217                                                 new ast::EnumInstType( decl, ast::CV::Const ),
    218                                                 // Construct a new EnumInstType as the type
    219                                                 tm->init,
    220                                                 tm->storage,
    221                                                 tm->linkage,
    222                                                 tm->bitfieldWidth,
    223                                                 {}, // enum member doesn't have attribute
    224                                                 tm->funcSpec
    225                                         );
    226                                         buffer.push_back(t);
    227                                 }
    228                         }
    229                 } else {
    230                         buffer.push_back( *it );
    231                 }
    232         }
    233         mut->members = buffer;
    234         decl = mut;
    235 
    236205        ForwardEnumsType::iterator fwds = forwardEnums.find( decl->name );
    237206        if ( fwds != forwardEnums.end() ) {
    … …  
    315284}
    316285
     286ast::QualifiedNameExpr const * LinkTypesCore::previsit( ast::QualifiedNameExpr const * decl ) {
     287        // Try to lookup type
     288        if ( auto objDecl = decl->type_decl.as<ast::ObjectDecl>() ) {
     289                if ( auto inst = objDecl->type.as<ast::TypeInstType>()) {
     290                        if ( auto enumDecl = symtab.lookupEnum ( inst->name ) ) {
     291                                auto mut = ast::mutate( decl );
     292                                mut->type_decl = enumDecl;
     293                                auto enumInst = new ast::EnumInstType( enumDecl );
     294                                enumInst->name = decl->name;
     295                                // Adding result; addCandidate() use result
     296                                mut->result = enumInst;
     297                                decl = mut;
     298                        }
     299                }
     300        } else if ( auto enumDecl = decl->type_decl.as<ast::EnumDecl>() ) {
     301                auto mut = ast::mutate( decl );
     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        // ast::EnumDecl const * decl = symtab.lookupEnum( type->name );
     309        // // It's not a semantic error if the enum is not found, just an implicit forward declaration.
     310        // if ( decl ) {
     311        //      // Just linking in the node.
     312        //      auto mut = ast::mutate( type );
     313        //      mut->base = const_cast<ast::EnumDecl *>( decl );
     314        //      type = mut;
     315        // }
     316        return decl;
     317}
     318
    317319} // namespace
    318320
Note: See TracChangeset for help on using the changeset viewer.