Changes in src/Validate/ImplementEnumFunc.cpp [822332e:85855b0]

File:

• src/Validate/ImplementEnumFunc.cpp (modified) (13 diffs)

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();