Changeset 85855b0 for src/Validate

Timestamp:

Jun 10, 2024, 2:43:13 AM (4 weeks ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

42cdd07d

Parents:

d68de59

Message:

1. Implement enum cast; 2. Change valueE so that opague enum returns quasi_void; 3. change enum hiding interpretation and pass visiting scheme

Location:

src/Validate

Files:

• Autogen.cpp (modified) (1 diff)
• EnumAndPointerDecay.cpp (modified) (1 diff)
• ImplementEnumFunc.cpp (modified) (13 diffs)

src/Validate/Autogen.cpp

@@ -410 +410 @@
 }
 
-/// Use the current type T to create `T ?{}(T & _dst, T _src)`.
+/// Use the current type T to create `T ?=?(T & _dst, T _src)`.
 ast::FunctionDecl * FuncGenerator::genAssignProto() const {
         // Only the name is different, so just reuse the generation function.

src/Validate/EnumAndPointerDecay.cpp

@@ -47 +47 @@
                                 new ast::EnumInstType( decl, ast::CV::Const ) ) );
                 } else if ( auto value = member.as<ast::InlineMemberDecl>() ) {
-                        if ( auto targetEnum = symtab.lookupEnum( value->name ) ) {
-                                for ( auto enumMember : targetEnum->members ) {
-                                        auto enumObject = enumMember.strict_as<ast::ObjectDecl>();
-                                        buffer.push_back( new ast::ObjectDecl(
-                                                // Get the location from the "inline" declaration.
-                                                value->location,
-                                                enumObject->name,
-                                                // Construct a new EnumInstType as the type.
-                                                new ast::EnumInstType( decl, ast::CV::Const ),
-                                                enumObject->init,
-                                                enumObject->storage,
-                                                enumObject->linkage,
-                                                enumObject->bitfieldWidth,
-                                                {},
-                                                enumObject->funcSpec
-                                        ) );
-                                }
+                        auto targetEnum = symtab.lookupEnum( value->name );
+                        // assert( targetEnum );
+                        if (!targetEnum) {
+                                SemanticError(value, "Only another enum is allowed for enum inline syntax ");
+                        }
+                        const ast::EnumInstType * instType = new ast::EnumInstType(targetEnum);
+                        mut->inlinedDecl.push_back( std::move(instType) );
+                        for ( auto enumMember : targetEnum->members ) {
+                                auto enumObject = enumMember.strict_as<ast::ObjectDecl>();
+                                buffer.push_back(new ast::ObjectDecl(
+                                        // Get the location from the "inline" declaration.
+                                        value->location,
+                                        enumObject->name,
+                                        // Construct a new EnumInstType as the type.
+                                        new ast::EnumInstType( decl, ast::CV::Const ),
+                                        enumObject->init,
+                                        enumObject->storage,
+                                        enumObject->linkage,
+                                        enumObject->bitfieldWidth,
+                                        {},
+                                        enumObject->funcSpec
+                                ));
                         }
                 }

src/Validate/ImplementEnumFunc.cpp

@@ -10 +10 @@
         const ast::EnumDecl* decl;
         unsigned int functionNesting;
+        const ast::StructDecl* quasi_void_decl;
         ast::Linkage::Spec proto_linkage;
 
@@ -24 +25 @@
                 : decl(decl),
                   functionNesting{functionNesting},
+                  quasi_void_decl(new ast::StructDecl(decl->location, 
+                        "quasi_void", ast::AggregateDecl::Struct,
+                        {}, ast::Linkage::AutoGen)),
                   proto_linkage{ast::Linkage::Cforall} {}
 
@@ -52 +56 @@
         void genSuccPredBody(ast::FunctionDecl *, const char *) const;
 
+        void genTypeNameFunc();
+
         // Implement TypedEnum trait
         void genTypedEnumFuncs();
@@ -58 +64 @@
         ast::FunctionDecl* genLabelProto() const;
         ast::FunctionDecl* genValueProto() const;
+        ast::FunctionDecl* genQuasiValueProto() const;
+        ast::FunctionDecl* genTypeNameProto() const;
+
         void genValueOrLabelBody(
                 ast::FunctionDecl* func, ast::ObjectDecl* arrDecl) const;
         void genPosnBody(ast::FunctionDecl* func) const;
-
-        ////////////////
-
-        // ---------------------------------------------------
-        // ast::FunctionDecl* genAttrCtorProto() const;
-        /// Changes the node inside a pointer so that it has the unused attribute.
-        void addUnusedAttribute(ast::ptr<ast::DeclWithType>& declPtr) {
-                ast::DeclWithType* decl = declPtr.get_and_mutate();
-                decl->attributes.push_back(new ast::Attribute("unused"));
-        }
+        void genQuasiValueBody(ast::FunctionDecl* func) const;
+        void genTypeNameBody(ast::FunctionDecl* func) const;
 
         // ----------------------------------------------------
@@ -117 +118 @@
         return inits;
 }
+
 const ast::Init* EnumAttrFuncGenerator::getAutoInit(
         const ast::Init* prev) const {
@@ -189 +191 @@
 
 ast::FunctionDecl* EnumAttrFuncGenerator::genValueProto() const {
+        if (decl->base)
+                return genProto(
+                        "valueE",
+                        {new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))},
+                        {new ast::ObjectDecl(getLocation(), "_ret",
+                                                                ast::deepCopy(decl->base))});
+        else
+                return genQuasiValueProto();
+}
+
+ast::FunctionDecl* EnumAttrFuncGenerator::genQuasiValueProto() const {
         return genProto(
                 "valueE",
                 {new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))},
                 {new ast::ObjectDecl(getLocation(), "_ret",
-                                     ast::deepCopy(decl->base))});
+                                                new ast::StructInstType(quasi_void_decl))});
 }
 
@@ -210 +223 @@
                 {new ast::ObjectDecl(getLocation(), "_ret", new ast::BasicType(ast::BasicKind::UnsignedInt))}
         );
+}
+
+ast::FunctionDecl* EnumAttrFuncGenerator::genTypeNameProto() const {
+        return genProto(
+                "type_name",
+                {new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))},
+                {new ast::ObjectDecl(
+                        getLocation(), "_ret",
+                        new ast::PointerType(new ast::BasicType{ast::BasicKind::Char}))});
 }
 
@@ -268 +290 @@
         );
 }
-
 
 void EnumAttrFuncGenerator::genSerialTraitFuncs() {
@@ -302 +323 @@
         const CodeLocation & loc = func->location;
         auto mem = func->name=="lowerBound"?  decl->members.front() : decl->members.back();
-        auto expr = new ast::NameExpr( loc, mem->name );
+        // auto expr = new ast::NameExpr( loc, mem->name );
+        auto expr = new ast::QualifiedNameExpr( loc, decl->name, mem->name );
         func->stmts = new ast::CompoundStmt( loc, {new ast::ReturnStmt(loc, expr)});
 }
@@ -349 +371 @@
 }
 
+void EnumAttrFuncGenerator::genQuasiValueBody(ast::FunctionDecl* func) const {
+        auto location = func->location;
+        const ast::ObjectDecl * objDecl = new ast::ObjectDecl(
+                location, "_out", new ast::StructInstType( quasi_void_decl ));
+        const ast::DeclStmt * declStmt = new ast::DeclStmt(location, objDecl);
+        const ast::VariableExpr * varExpr = new ast::VariableExpr(location, objDecl);
+        const ast::ReturnStmt * retStmt = new ast::ReturnStmt(location, varExpr);
+
+        func->stmts = new ast::CompoundStmt(
+                location, {declStmt, retStmt}
+        );
+}
+
 void EnumAttrFuncGenerator::genPosnBody(ast::FunctionDecl* func) const {
         auto castExpr = new ast::CastExpr(
@@ -359 +394 @@
 }
 
+void EnumAttrFuncGenerator::genTypeNameBody(ast::FunctionDecl* func) const {
+        const ast::Expr * type_name = ast::ConstantExpr::from_string(func->location, decl->name);
+        func->stmts = new ast::CompoundStmt(
+                func->location, {new ast::ReturnStmt(func->location, type_name)}
+        );
+}
+
 void EnumAttrFuncGenerator::genTypedEnumFunction(const ast::EnumAttribute attr) {
-        if (attr == ast::EnumAttribute::Value ||
-                attr == ast::EnumAttribute::Label) {
-                // TypedEnum's backing arrays
-                std::vector<ast::ptr<ast::Init>> inits =
-                        attr == ast::EnumAttribute::Value ? genValueInit() : genLabelInit();
+        if (attr == ast::EnumAttribute::Value) {
+                if (decl->base) {
+                        // TypedEnum's backing arrays
+                        std::vector<ast::ptr<ast::Init>> inits = genValueInit();
+                        ast::ObjectDecl* arrayProto =
+                                genAttrArrayProto(attr, getLocation(), inits);
+                        forwards.push_back(arrayProto);
+
+                        ast::FunctionDecl* funcProto = genValueProto();
+                        produceForwardDecl(funcProto);
+                        genValueOrLabelBody(funcProto, arrayProto);
+                        produceDecl(funcProto);
+                }  else {
+                        ast::FunctionDecl* funcProto = genQuasiValueProto();
+                        produceForwardDecl(funcProto);
+                        genQuasiValueBody(funcProto);
+                        produceDecl(funcProto);
+                }
+        } else if (attr == ast::EnumAttribute::Label) {
+                std::vector<ast::ptr<ast::Init>> inits = genLabelInit();
                 ast::ObjectDecl* arrayProto =
                         genAttrArrayProto(attr, getLocation(), inits);
                 forwards.push_back(arrayProto);
-
-                ast::FunctionDecl* funcProto = ( attr == ast::EnumAttribute::Value )
-                                               ? genValueProto()
-                                               : genLabelProto();
+                ast::FunctionDecl* funcProto = genLabelProto();
                 produceForwardDecl(funcProto);
                 genValueOrLabelBody(funcProto, arrayProto);
@@ -384 +438 @@
 
 void EnumAttrFuncGenerator::genTypedEnumFuncs() {
-        if (decl->base) genTypedEnumFunction(ast::EnumAttribute::Value);
+        genTypedEnumFunction(ast::EnumAttribute::Value);
         genTypedEnumFunction(ast::EnumAttribute::Label);
         genTypedEnumFunction(ast::EnumAttribute::Posn);
+}
+
+void EnumAttrFuncGenerator::genTypeNameFunc() {
+        ast::FunctionDecl* funcProto = genTypeNameProto();
+        produceForwardDecl(funcProto);
+        genTypeNameBody(funcProto);
+        produceDecl(funcProto);
 }
 
@@ -392 +453 @@
         std::list<ast::ptr<ast::Decl>>& decls) {
         // Generate the functions (they go into forwards and definitions).
+        genTypeNameFunc();
         genTypedEnumFuncs();
         genSerialTraitFuncs();