Changes in src/Validate/Autogen.cpp [0522ebe:bbf2cb1]

File:

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

src/Validate/Autogen.cpp

@@ -133 +133 @@
         /// Generates a single struct member operation.
         /// (constructor call, destructor call, assignment call)
-        // This is managed because it uses another helper that returns a ast::ptr.
-        ast::ptr<ast::Stmt> makeMemberOp(
+        const ast::Stmt * makeMemberOp(
                 const CodeLocation& location,
                 const ast::ObjectDecl * dstParam, const ast::Expr * src,
@@ -198 +197 @@
         bool shouldAutogen() const final { return true; }
         void genAttrFuncForward();
+        void genPosFunctions();
 private:
         void genFuncBody( ast::FunctionDecl * decl ) final;
@@ -206 +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;
+
+        ast::FunctionDecl * genSuccPredFunc( bool succ );
+        // ast::FunctionDecl * genPredFunc();
 };
 
@@ -251 +258 @@
         if ( enumDecl->base ) {
                 gen.genAttrFuncForward();
+                gen.genPosFunctions();
         }
         gen.generateAndAppendFunctions( declsToAddAfter );
@@ -525 +533 @@
 }
 
-ast::ptr<ast::Stmt> StructFuncGenerator::makeMemberOp(
+const ast::Stmt * StructFuncGenerator::makeMemberOp(
                 const CodeLocation& location, const ast::ObjectDecl * dstParam,
                 const ast::Expr * src, const ast::ObjectDecl * field,
@@ -540 +548 @@
                 )
         );
-        auto stmt = genImplicitCall(
+        const ast::Stmt * stmt = genImplicitCall(
                 srcParam, dstSelect, location, func->name,
                 field, direction
@@ -598 +606 @@
                         location, field, new ast::VariableExpr( location, srcParam )
                 ) : nullptr;
-                ast::ptr<ast::Stmt> stmt =
+                const ast::Stmt * stmt =
                         makeMemberOp( location, dstParam, srcSelect, field, func, direction );
 
                 if ( nullptr != stmt ) {
-                        stmts->kids.push_back( stmt );
+                        stmts->kids.emplace_back( stmt );
                 }
         }
@@ -623 +631 @@
         for ( auto param = params.begin() + 1 ; current != end ; ++current ) {
                 const ast::ptr<ast::Decl> & member = *current;
-                ast::ptr<ast::Stmt> stmt = nullptr;
+                const ast::Stmt * stmt = nullptr;
                 auto field = member.as<ast::ObjectDecl>();
                 // Not sure why it could be null.
@@ -641 +649 @@
 
                 if ( nullptr != stmt ) {
-                        stmts->kids.push_back( stmt );
+                        stmts->kids.emplace_back( stmt );
                 }
         }
@@ -791 +799 @@
 }
 
-// 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( "_successor_",
+                { 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( "_predessor_",
+                { 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::genSuccPredFunc( bool succ ) {
+        ast::FunctionDecl * decl = succ? genSuccPosProto(): genPredPosProto();
+        produceForwardDecl( decl );
+
+        const CodeLocation& location = getLocation();
+
+        auto & params = decl->params;
+        assert( params.size() == 1 );
+        auto param = params.front().strict_as<ast::ObjectDecl>();
+
+        auto newReturn = new ast::ObjectDecl( location, "_returns",
+                new ast::BasicType{ ast::BasicType::SignedInt} );
+        
+
+        ast::UntypedExpr * addOneExpr = new ast::UntypedExpr( location,
+                new ast::NameExpr( location, succ? "?+?": "?-?" )
+        );
+        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
+        );
+
+        decl->stmts = new ast::CompoundStmt( location, 
+                {
+                        new ast::DeclStmt( location, newReturn ),
+                        new ast::ExprStmt( location, assignExpr ),
+                        new ast::ReturnStmt( location, 
+                                new ast::VariableExpr( location, newReturn )) 
+                } );
+        
+        return decl;
+}
 
 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
+                        // ,&EnumFuncGenerator::genSuccPosProto,
+                        // &EnumFuncGenerator::genPredPosProto
+                };
                 for ( auto & generator : attrProtos ) {
                         produceForwardDecl( (this->*generator)() );
                 }
         }
+}
+
+void EnumFuncGenerator::genPosFunctions() {
+        if ( decl->base ) {
+                ast::FunctionDecl * succ = genSuccPredFunc( true );
+                ast::FunctionDecl * pred = genSuccPredFunc( false );
+                produceDecl( succ );
+                produceDecl( pred );
+        }
+
 }