Changeset 00eaeb8 for src

Timestamp:

Mar 1, 2024, 4:32:35 PM (11 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

bbf2cb1

Parents:

f1149ac

Message:

Add prototype of succ function

Location:

src

Files:

• ResolvExpr/ConversionCost.cc (modified) (3 diffs)
• Validate/Autogen.cpp (modified) (4 diffs)

src/ResolvExpr/ConversionCost.cc

@@ -288 +288 @@
             cost = Cost::unsafe;
                 }
+        } else if ( dynamic_cast< const ast::EnumPosType *>(dst) ) {
+                static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
+                cost = costCalc( basicType, integer, srcIsLvalue, symtab, env );
         }
 }
@@ -366 +369 @@
         static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
         cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
-        // }
         if ( cost < Cost::unsafe ) {
                 cost.incSafe();
@@ -373 +375 @@
 
 void ConversionCost::postvisit( const ast::EnumPosType * ) {
-        static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
-        cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
-        if ( cost < Cost::unsafe ) {
-                cost.incSafe();
-        }
+        if ( dynamic_cast<const ast::EnumPosType *>( dst ) ) {
+                // Tempoarary
+                cost = Cost::zero;
+        } else {
+                static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
+                cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
+                if ( cost < Cost::unsafe ) {
+                        cost.incSafe();
+                }
+        }
+
 }
 

src/Validate/Autogen.cpp

@@ -197 +197 @@
         bool shouldAutogen() const final { return true; }
         void genAttrFuncForward();
+        void genPosFunctions();
 private:
         void genFuncBody( ast::FunctionDecl * decl ) final;
@@ -205 +206 @@
         ast::FunctionDecl * genLabelProto() const;
         ast::FunctionDecl * genValueProto() const;
-        // ast::FunctionDecl * genValueProto2() const;
+        ast::FunctionDecl * genSuccProto() const;
+        ast::FunctionDecl * genPredProto() const;
+
+        ast::FunctionDecl * genSuccPosProto() const;
+        ast::FunctionDecl * genPredPosProto() const;
+
+        void genSuccFunc(ast::FunctionDecl *);
 };
 
@@ -250 +257 @@
         if ( enumDecl->base ) {
                 gen.genAttrFuncForward();
+                gen.genPosFunctions();
         }
         gen.generateAndAppendFunctions( declsToAddAfter );
@@ -790 +798 @@
 }
 
-// ast::FunctionDecl * EnumFuncGenerator::genValueProto2() const {
-//      return genProto( "valueE", 
-//              { new ast::ObjectDecl( getLocation(), "_i", new ast::EnumPosType( new ast::EnumInstType( decl ) ) )},
-//              { new ast::ObjectDecl( getLocation(), "_ret", ast::deepCopy( decl->base ) ) } );
-// }
+ast::FunctionDecl * EnumFuncGenerator::genSuccProto() const {
+        return genProto( "succ",
+                { new ast::ObjectDecl( getLocation(), "_i", new ast::EnumInstType( decl ) )},
+                { new ast::ObjectDecl( getLocation(), "_ret", new ast::EnumInstType( decl ))} ); 
+}
+
+ast::FunctionDecl * EnumFuncGenerator::genPredProto() const {
+        return genProto( "pred",
+                { new ast::ObjectDecl( getLocation(), "_i", new ast::EnumInstType( decl ))},
+                { new ast::ObjectDecl( getLocation(), "_ret", new ast::EnumInstType( decl ))} );
+}
+
+ast::FunctionDecl * EnumFuncGenerator::genSuccPosProto() const {
+        return genProto( "succ",
+                { new ast::ObjectDecl( getLocation(), "_i", 
+                        new ast::EnumPosType( new ast::EnumInstType( decl ) ) )},
+                { 
+                        new ast::ObjectDecl( getLocation(), "_ret", 
+                        new ast::EnumPosType( new ast::EnumInstType( decl ) ) )
+                } ); 
+}
+
+ast::FunctionDecl * EnumFuncGenerator::genPredPosProto() const {
+        return genProto( "pred",
+                { new ast::ObjectDecl( getLocation(), "_i", 
+                        new ast::EnumPosType( new ast::EnumInstType( decl ) ) )},
+                { 
+                        new ast::ObjectDecl( getLocation(), "_ret", 
+                        new ast::EnumPosType( new ast::EnumInstType( decl ) ) )
+                } ); 
+}
+
+void EnumFuncGenerator::genSuccFunc(ast::FunctionDecl * succDecl) {
+        const CodeLocation& location = getLocation();
+
+        auto & params = succDecl->params;
+        assert( params.size() == 1 );
+        auto param = params.front().strict_as<ast::ObjectDecl>();
+
+        // auto & returns = succDecl->returns;
+        // assert( returns.size() == 1 );
+        // auto oldRet = returns.front().strict_as<ast::ObjectDecl>();
+
+        // auto param = new ast::ObjectDecl( getLocation(), "_i", 
+        //              new ast::EnumPosType( new ast::EnumInstType( decl ) ) );
+
+        auto newReturn = new ast::ObjectDecl( location, "_returns",
+                new ast::BasicType{ ast::BasicType::SignedInt} );
+        
+
+        ast::UntypedExpr * addOneExpr = new ast::UntypedExpr( location,
+                new ast::NameExpr( location, "?+?" )
+        );
+        addOneExpr->args.push_back( 
+                new ast::CastExpr( location, 
+                        new ast::VariableExpr( location, param ),
+                        new ast::BasicType{ ast::BasicType::SignedInt }
+                )
+        );
+        addOneExpr->args.push_back( 
+                ast::ConstantExpr::from_int( location, 1 )
+        );
+
+        ast::UntypedExpr * assignExpr = new ast::UntypedExpr( location,
+                new ast::NameExpr( location, "?=?" )
+        );
+        assignExpr->args.push_back(     
+                new ast::VariableExpr( location, newReturn )
+        );
+        assignExpr->args.push_back(
+                addOneExpr
+        );
+
+        succDecl->stmts = new ast::CompoundStmt( location, 
+                {
+                        new ast::DeclStmt( location, newReturn ),
+                        new ast::ExprStmt( location, assignExpr ),
+                        new ast::ReturnStmt( location, 
+                                new ast::VariableExpr( location, newReturn )) 
+                } );
+}
 
 void EnumFuncGenerator::genAttrFuncForward() {  
         if ( decl->base ) {
-                ast::FunctionDecl *(EnumFuncGenerator::*attrProtos[3])() const = {
+                ast::FunctionDecl *(EnumFuncGenerator::*attrProtos[5])() const = {
                         &EnumFuncGenerator::genPosProto, &EnumFuncGenerator::genLabelProto, 
-                        &EnumFuncGenerator::genValueProto
-                        // , &EnumFuncGenerator::genValueProto2 
-                        };
+                        &EnumFuncGenerator::genValueProto, &EnumFuncGenerator::genSuccProto,
+                        &EnumFuncGenerator::genPredProto
+                };
                 for ( auto & generator : attrProtos ) {
                         produceForwardDecl( (this->*generator)() );
                 }
         }
+}
+
+void EnumFuncGenerator::genPosFunctions() {
+        if ( decl->base ) {
+                ast::FunctionDecl * decl = genSuccPosProto();
+                produceForwardDecl( decl );
+                genSuccFunc (decl );
+                produceDecl( decl );
+        }
+
 }