Changeset bb336a6 for src

Timestamp:

Jul 10, 2024, 3:39:26 AM (5 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

dbff8ec

Parents:

550afde2

Message:

Fixed the problem when enum use another enumerator as initializer

Location:

src

Files:

• AST/Create.cpp (modified) (1 diff)
• AST/Create.hpp (modified) (1 diff)
• ResolvExpr/ResolveTypeof.cpp (modified) (1 diff)
• Validate/Autogen.cpp (modified) (4 diffs)
• Validate/ImplementEnumFunc.cpp (modified) (5 diffs)

src/AST/Create.cpp

@@ -76 +76 @@
 }
 
+EnumDecl * asForward( EnumDecl const * decl ) {
+        if ( !decl->body ) {
+                return nullptr;
+        }
+        EnumDecl * fwd = new EnumDecl( decl->location,
+                decl->name,
+                decl->isCfa,
+                vectorCopy( decl->attributes ),
+                decl->linkage,
+                decl->base,
+                decl->hide
+        );
+        fwd->params = vectorCopy( decl->params );
+        return fwd;
 }
+
+}

src/AST/Create.hpp

@@ -24 +24 @@
 StructDecl * asForward( StructDecl const * );
 UnionDecl * asForward( UnionDecl const * );
+EnumDecl * asForward( EnumDecl const * );
 
 }

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) );
-                        }
+                        // if ( newType.as< ast::EnumInstType >() ) {
+                        //      newType = new ast::BasicType(
+                        //              ast::BasicKind::SignedInt, newType->qualifiers, copy(newType->attributes) );
+                        // }
                         reset_qualifiers(
                                 newType,

src/Validate/Autogen.cpp

@@ -88 +88 @@
 
         // Internal helpers:
-        void genStandardFuncs();
+        virtual void genStandardFuncs();
         void produceDecl( const ast::FunctionDecl * decl );
         void produceForwardDecl( const ast::FunctionDecl * decl );
@@ -196 +196 @@
 
         bool shouldAutogen() const final { return true; }
+        void generateAndPrependDecls( std::list<ast::ptr<ast::Decl>> & );
+        void genForwards();
 private:
         void genFuncBody( ast::FunctionDecl * decl ) final;
         void genFieldCtors() final;
         const ast::Decl * getDecl() const final { return decl; }
+protected:
+        void genStandardFuncs() override;
 };
 
@@ -242 +246 @@
         enumInst.base = enumDecl;
         EnumFuncGenerator gen( enumDecl, &enumInst, functionNesting );
-        gen.generateAndAppendFunctions( declsToAddAfter );
+        gen.generateAndPrependDecls( declsToAddBefore );
+
+        EnumFuncGenerator gen2( enumDecl, &enumInst, functionNesting );
+        gen2.generateAndAppendFunctions( declsToAddAfter );
 }
 
@@ -709 +716 @@
 }
 
+void EnumFuncGenerator::generateAndPrependDecls( std::list<ast::ptr<ast::Decl>> & decls ) {
+        genForwards();
+        decls.splice( decls.end(), forwards );
+}
+
+void EnumFuncGenerator::genForwards() {
+        forwards.push_back( ast::asForward(decl) );
+
+        ast::FunctionDecl *(FuncGenerator::*standardProtos[4])() const = {
+                &EnumFuncGenerator::genCtorProto, &EnumFuncGenerator::genCopyProto,
+                &EnumFuncGenerator::genDtorProto, &EnumFuncGenerator::genAssignProto };
+
+        for ( auto & generator: standardProtos) {
+                ast::FunctionDecl * decl = (this->*generator)();
+                produceForwardDecl( decl );
+        }
+}
+
+void EnumFuncGenerator::genStandardFuncs() {
+        // do everything FuncGenerator does except not make ForwardDecls
+        ast::FunctionDecl *(FuncGenerator::*standardProtos[4])() const = {
+                &EnumFuncGenerator::genCtorProto, &EnumFuncGenerator::genCopyProto,
+                &EnumFuncGenerator::genDtorProto, &EnumFuncGenerator::genAssignProto };
+
+        for ( auto & generator : standardProtos ) {
+                ast::FunctionDecl * decl = (this->*generator)();
+                // produceForwardDecl( decl ); Done in genForwards
+                genFuncBody( decl );
+                if ( CodeGen::isAssignment( decl->name ) ) {
+                        appendReturnThis( decl );
+                }
+                produceDecl( decl );
+        }
+}
+
 void EnumFuncGenerator::genFieldCtors() {
         // Enumerations to not have field constructors.

src/Validate/ImplementEnumFunc.cpp

@@ -104 +104 @@
                 auto memAsObjectDecl = mem.as<ast::ObjectDecl>();
                 assert(memAsObjectDecl);
-                if (memAsObjectDecl->init) {
+                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;
+                                }
+                        }
+
                         inits.emplace_back(memAsObjectDecl->init);
                 } else {
@@ -406 +429 @@
 void EnumAttrFuncGenerator::genTypedEnumFunction(const ast::EnumAttribute attr) {
         if (attr == ast::EnumAttribute::Value) {
-                if (decl->base) {
+                if (decl->isTyped()) {
                         // TypedEnum's backing arrays
                         std::vector<ast::ptr<ast::Init>> inits = genValueInit();
@@ -441 +464 @@
 
 void EnumAttrFuncGenerator::genTypedEnumFuncs() {
-        genTypedEnumFunction(ast::EnumAttribute::Value);
-        genTypedEnumFunction(ast::EnumAttribute::Label);
-        genTypedEnumFunction(ast::EnumAttribute::Posn);
+        // genTypedEnumFunction(ast::EnumAttribute::Value);
+        // genTypedEnumFunction(ast::EnumAttribute::Label);
+        // genTypedEnumFunction(ast::EnumAttribute::Posn);
 }
 
@@ -456 +479 @@
         std::list<ast::ptr<ast::Decl>>& decls) {
         // Generate the functions (they go into forwards and definitions).
-        genTypeNameFunc();
+        // genTypeNameFunc();
         genTypedEnumFuncs();
-        genSerialTraitFuncs();
-        genBoundedFunctions();
+        // genSerialTraitFuncs();
+        // genBoundedFunctions();
         // Now export the lists contents.
         decls.splice(decls.end(), forwards);
@@ -483 +506 @@
         enumInst.base = enumDecl;
         EnumAttrFuncGenerator gen(enumDecl, &enumInst, functionNesting);
-        gen.generateAndAppendFunctions(declsToAddAfter);
+        // gen.generateAndAppendFunctions(declsToAddAfter);
 }