Changeset 9d5eacb for src

Timestamp:

Jul 10, 2024, 6:55:54 PM (5 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

236f133, 3be81a4

Parents:

725f777f

Message:

Fix the bug with typed anomynous enum got incorrect forward declaration

Location:

src

Files:

• Parser/DeclarationNode.hpp (modified) (1 diff)
• ResolvExpr/ResolveTypeof.cpp (modified) (1 diff)
• Validate/Autogen.cpp (modified) (2 diffs)
• Validate/ImplementEnumFunc.cpp (modified) (1 diff)

src/Parser/DeclarationNode.hpp

@@ -27 +27 @@
         static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );
         static DeclarationNode * newAggregate( ast::AggregateDecl::Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
-        static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed, DeclarationNode * base = nullptr, EnumHiding hiding = EnumHiding::Visible );
+        static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool isCfa = false, DeclarationNode * base = nullptr, EnumHiding hiding = EnumHiding::Visible );
         static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant );
         static DeclarationNode * newEnumValueGeneric( const std::string * name, InitializerNode * init );

src/ResolvExpr/ResolveTypeof.cpp

@@ -61 +61 @@
                 if ( typeofType->kind == ast::TypeofType::Basetypeof ) {
                         // replace basetypeof(<enum>) by int
-                        // if ( newType.as< ast::EnumInstType >() ) {
-                        //      newType = new ast::BasicType(
-                        //              ast::BasicKind::SignedInt, newType->qualifiers, copy(newType->attributes) );
-                        // }
+                        auto enumInst = newType.as< ast::EnumInstType >();
+                        if ( enumInst && (!enumInst->base || !enumInst->base->isCfa) ) {
+                                newType = new ast::BasicType(
+                                        ast::BasicKind::SignedInt, newType->qualifiers, copy(newType->attributes) );
+                        }
                         reset_qualifiers(
                                 newType,

src/Validate/Autogen.cpp

@@ -245 +245 @@
         ast::EnumInstType enumInst( enumDecl->name );
         enumInst.base = enumDecl;
-        EnumFuncGenerator gen( enumDecl, &enumInst, functionNesting );
-        gen.generateAndPrependDecls( declsToAddBefore );
+        if ( enumDecl->isCfa ) {
+                EnumFuncGenerator gen( enumDecl, &enumInst, functionNesting );
+                gen.generateAndPrependDecls( declsToAddBefore );
+        }
 
         EnumFuncGenerator gen2( enumDecl, &enumInst, functionNesting );
@@ -742 +744 @@
         for ( auto & generator : standardProtos ) {
                 ast::FunctionDecl * decl = (this->*generator)();
-                // produceForwardDecl( decl ); Done in genForwards
+                produceForwardDecl( decl );
                 genFuncBody( decl );
                 if ( CodeGen::isAssignment( decl->name ) ) {

src/Validate/ImplementEnumFunc.cpp

@@ -105 +105 @@
                 assert(memAsObjectDecl);
                 if (auto& init = memAsObjectDecl->init) {
-                        auto singleInit = init.strict_as<ast::SingleInit>();
-                        auto nameExpr = singleInit->value.as<ast::NameExpr>();
-                        if (nameExpr) {
-                                auto name = nameExpr->name;
-                                if (auto it = std::find_if(decl->members.begin(), decl->members.end(), 
-                                        [name](ast::ptr<ast::Decl> mem_decl) {
-                                                return (mem_decl->name == name);
-                                        }); it != std::end(decl->members)
-                                ) {
-                                        // ast::SingleInit* newInit = new ast::SingleInit(
-                                        //      init->location, new ast::CastExpr( nameExpr->location, 
-                                        //      nameExpr, new ast::BasicType( ast::BasicKind::UnsignedInt ), ast::ExplicitCast )
-                                        // );
-                                        // auto targetInit = (*it).strict_as<ast::ObjectDecl>()->init;
-                                        // inits.emplace_back( targetInit );
-                                        auto index = std::distance( decl->members.begin(), it );
-                                        auto targetInit = inits.at(index).strict_as<ast::SingleInit>();
-                                        auto targetExpr = targetInit->value;
-                                        inits.push_back( new ast::SingleInit( targetExpr->location, targetExpr ) );
-                                        continue;
+                        if ( auto singleInit = init.as<ast::SingleInit>() ) {
+                                if ( auto nameExpr = singleInit->value.as<ast::NameExpr>() ) {
+                                        auto name = nameExpr->name;
+                                        if (auto it = std::find_if(decl->members.begin(), decl->members.end(),
+                                                [name](ast::ptr<ast::Decl> mem_decl) {
+                                                        return (mem_decl->name == name);
+                                                }); it != std::end(decl->members)
+                                        ) {
+                                                auto index = std::distance( decl->members.begin(), it );
+                                                auto targetInit = inits.at(index).strict_as<ast::SingleInit>();
+                                                auto targetExpr = targetInit->value;
+                                                inits.push_back( new ast::SingleInit( targetExpr->location, targetExpr ) );
+                                                continue;
+                                        }
                                 }
                         }
-
                         inits.emplace_back(memAsObjectDecl->init);
                 } else {