Changeset c75b30a for src/Validate/Autogen.cpp

Timestamp:

Jan 31, 2024, 6:25:02 PM (4 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

32490deb

Parents:

16afb2a

Message:

Introduce posE, valueE, labelE pseudo language to the language. Rework the internal representation of enumeration.

File:

• src/Validate/Autogen.cpp (modified) (4 diffs)

src/Validate/Autogen.cpp

@@ -197 +197 @@
 
         bool shouldAutogen() const final { return true; }
+        void genAttrFuncForward();
+        void __attribute__ ((unused)) genDualFuncs();
 private:
         void genFuncBody( ast::FunctionDecl * decl ) final;
         void genFieldCtors() final;
         const ast::Decl * getDecl() const final { return decl; }
+
+        ast::ObjectDecl * dualDstParam() const;
+
+        ast::FunctionDecl * genPosProto() const;
+        ast::FunctionDecl * genLabelProto() const;
+        ast::FunctionDecl * genValueProto() const;
+
+        ast::FunctionDecl * genCopyEnumToDualProto() const;
+        ast::FunctionDecl * genAssignEnumToDualProto() const;
+
+        void genDualBody( ast::FunctionDecl * decl );
 };
 
@@ -238 +251 @@
 // --------------------------------------------------------------------------
 void AutogenerateRoutines::previsit( const ast::EnumDecl * enumDecl ) {
-        // Must visit children (enum constants) to add them to the symbol table.
         if ( !enumDecl->body ) return;
-
-        // if ( auto enumBaseType = enumDecl->base ) {
-        //      if ( auto enumBaseTypeAsStructInst = dynamic_cast<const ast::StructInstType *>(enumBaseType.get()) ) {
-        //              const ast::StructDecl * structDecl = enumBaseTypeAsStructInst->base.get();
-        //              this->previsit( structDecl );
-        //      }
-        // }
 
         ast::EnumInstType enumInst( enumDecl->name );
         enumInst.base = enumDecl;
         EnumFuncGenerator gen( enumDecl, &enumInst, functionNesting );
+        if ( enumDecl->base ) {
+                gen.genAttrFuncForward();
+                // gen.genDualFuncs();
+        }
         gen.generateAndAppendFunctions( declsToAddAfter );
 }
@@ -742 +751 @@
                  * returns to zero.
                  */
+                auto dstExpr = new ast::VariableExpr( location, dstParam );
+                const ast::Expr * srcExpr;
+                if ( decl->base ) {
+                        srcExpr = new ast::ApplicationExpr( location,
+                        ast::VariableExpr::functionPointer( location, genPosProto() ), 
+                        {
+                                new ast::VariableExpr( location, srcParam )
+                        }
+                        );
+                } else {
+                        srcExpr = new ast::VariableExpr( location, srcParam );
+                }
+
                 auto callExpr = new ast::ApplicationExpr( location,
                         ast::VariableExpr::functionPointer( location, functionDecl ),
                         {
-                                new ast::VariableExpr( location, dstParam ),
-                                new ast::VariableExpr( location, srcParam ),
+                                dstExpr,
+                                srcExpr,
                         }
                 );
-                // auto fname = ast::getFunctionName( callExpr );
-                // if (fname == "posE" ) {
-                //      std::cerr << "Found posE autogen" << std::endl;
-                // }
+
                 functionDecl->stmts = new ast::CompoundStmt( location,
                         { new ast::ExprStmt( location, callExpr ) }
@@ -768 +787 @@
                         forwards.back().get_and_mutate() );
                 addUnusedAttribute( fwd->params.front() );
+        }
+}
+
+ast::FunctionDecl * EnumFuncGenerator::genPosProto() const {
+        return genProto( "posE", 
+                { new ast::ObjectDecl( getLocation(), "_i", 
+                new ast::EnumInstType( decl ) )}, 
+                { new ast::ObjectDecl( getLocation(), "_ret", 
+                new ast::BasicType{ ast::BasicType::UnsignedInt } )} );
+}
+
+ast::FunctionDecl * EnumFuncGenerator::genLabelProto() const {
+        return genProto( "labelE",
+                { new ast::ObjectDecl( getLocation(), "_i", 
+                new ast::EnumInstType( decl ) ) },
+                { new ast::ObjectDecl( getLocation(), "_ret", 
+                new ast::PointerType( new ast::BasicType{ ast::BasicType::Char } ) ) } );
+}
+
+ast::FunctionDecl * EnumFuncGenerator::genValueProto() const {
+        return genProto( "valueE", 
+                { new ast::ObjectDecl( getLocation(), "_i", new ast::EnumInstType( decl ) )},
+                { new ast::ObjectDecl( getLocation(), "_ret", ast::deepCopy( decl->base ) ) } );
+}
+
+void EnumFuncGenerator::genAttrFuncForward() {  
+        if ( decl->base ) {
+                ast::FunctionDecl *(EnumFuncGenerator::*attrProtos[3])() const = {
+                        &EnumFuncGenerator::genPosProto, &EnumFuncGenerator::genLabelProto, 
+                        &EnumFuncGenerator::genValueProto };
+                for ( auto & generator : attrProtos ) {
+                        produceForwardDecl( (this->*generator)() );
+                }
+        }
+}
+
+ast::ObjectDecl * EnumFuncGenerator::dualDstParam() const {
+        auto base = decl->base;
+        assert( base );
+        return new ast::ObjectDecl( getLocation(), "_dst",
+                new ast::ReferenceType( ast::deepCopy( base ) ) );
+}
+
+// void ?{}(T & _dst, enum E _src )
+ast::FunctionDecl * EnumFuncGenerator::genCopyEnumToDualProto() const {
+        return genProto( "?{}", { dualDstParam(), srcParam() }, {} );
+}
+
+// T ?{}(T & _dst, enum E _src )
+ast::FunctionDecl * EnumFuncGenerator::genAssignEnumToDualProto() const {
+        auto retval = dualDstParam();
+        retval->name = "_ret";
+        return genProto( "?=?", { dualDstParam(), srcParam() }, { retval });
+}
+
+void EnumFuncGenerator::genDualBody( ast::FunctionDecl * functionDecl ) {
+        assert( decl->base );
+        const CodeLocation& location = functionDecl->location;
+        auto & params = functionDecl->params;
+        
+        assert( 2 == params.size() );
+        auto dstParam = params.front().strict_as<ast::ObjectDecl>();
+        auto srcParam = params.back().strict_as<ast::ObjectDecl>();
+
+        auto dstExpr = new ast::VariableExpr( location, dstParam );
+
+        auto srcExpr = new ast::ApplicationExpr( location,
+                ast::VariableExpr::functionPointer( location, genValueProto() ),
+                {
+                        new ast::VariableExpr( location, srcParam )
+                });
+        auto callExpr = new ast::ApplicationExpr( location,
+                ast::VariableExpr::functionPointer( location, functionDecl ),
+                { dstExpr, srcExpr } );
+        functionDecl->stmts = new ast::CompoundStmt( location,
+                { new ast::ExprStmt( location, callExpr)} );
+}
+
+void EnumFuncGenerator::genDualFuncs() {
+        assert( decl->base );
+        ast::FunctionDecl *(EnumFuncGenerator::*dualProtos[2])() const = {
+                        &EnumFuncGenerator::genCopyEnumToDualProto, 
+                        &EnumFuncGenerator::genAssignEnumToDualProto };
+        for ( auto & generator : dualProtos ) {
+                ast::FunctionDecl * decl = (this->*generator)();
+                produceForwardDecl( decl );
+                genDualBody( decl );
+                if ( CodeGen::isAssignment( decl->name ) ) {
+                        appendReturnThis( decl );
+                }
+                produceDecl( decl );
         }
 }