Changeset 44adf1b

Timestamp:

Mar 5, 2024, 9:55:04 AM (11 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

af60383

Parents:

9262fe9

Message:

Removed casts around get_next (also replaced with direct field access) that are no longer needed.

Location:

src/Parser

Files:

• DeclarationNode.cc (modified) (2 diffs)
• ExpressionNode.h (modified) (1 diff)
• InitializerNode.cc (modified) (5 diffs)
• ParseNode.h (modified) (1 diff)
• StatementNode.cc (modified) (3 diffs)
• TypeData.cc (modified) (5 diffs)
• parser.yy (modified) (4 diffs)

src/Parser/DeclarationNode.cc

@@ -101 +101 @@
 DeclarationNode * DeclarationNode::clone() const {
         DeclarationNode * newnode = new DeclarationNode;
-        newnode->set_next( maybeCopy( get_next() ) );
+        newnode->next = maybeCopy( next );
         newnode->name = name ? new string( *name ) : nullptr;
 
@@ -717 +717 @@
 
                 // there may be typedefs chained onto the type
-                if ( o->get_next() ) {
-                        set_last( o->get_next()->clone() );
+                if ( o->next ) {
+                        set_last( o->next->clone() );
                 } // if
         } // if

src/Parser/ExpressionNode.h

@@ -26 +26 @@
                 if ( nullptr == expr ) return nullptr;
                 ExpressionNode * node = new ExpressionNode( ast::shallowCopy( expr.get() ) );
-                node->set_next( maybeCopy( get_next() ) );
+                node->next = maybeCopy( next );
                 return node;
         }

src/Parser/InitializerNode.cc

@@ -36 +36 @@
                 : expr( _expr ), aggregate( aggrp ), designator( des ), kids( nullptr ), maybeConstructed( true ), isDelete( false ) {
         if ( aggrp )
-                kids = dynamic_cast< InitializerNode * >( get_next() );
+                kids = next;
 
         if ( kids )
@@ -48 +48 @@
 
         if ( aggrp )
-                kids = dynamic_cast< InitializerNode * >( get_next() );
+                kids = next;
 
         if ( kids )
-                set_next( nullptr );
+                next = nullptr;
 } // InitializerNode::InitializerNode
 
@@ -73 +73 @@
                         while ( curdes != nullptr) {
                                 curdes->printOneLine(os);
-                                curdes = (ExpressionNode *)(curdes->get_next());
+                                curdes = curdes->next;
                                 if ( curdes ) os << ", ";
                         } // while
@@ -87 +87 @@
 
         InitializerNode *moreInit;
-        if ( (moreInit = dynamic_cast< InitializerNode * >( get_next() ) ) ) {
+        if ( ( moreInit = next ) ) {
                 moreInit->printOneLine( os );
         } // if
@@ -98 +98 @@
                 std::vector<ast::ptr<ast::Designation>> designlist;
                 InitializerNode * child = next_init();
-                for ( ; child != nullptr ; child = dynamic_cast< InitializerNode * >( child->get_next() ) ) {
+                for ( ; child != nullptr ; child = child->next ) {
                         std::deque<ast::ptr<ast::Expr>> desList;
                         buildList( child->designator, desList );

src/Parser/ParseNode.h

@@ -64 +64 @@
         virtual ParseList<Next> * clone() const = 0;
 
-        Next * get_next() const { return next; }
-        void set_next( Next * newlink ) { next = newlink; }
-
         Next * get_last() {
                 Next * current = static_cast<Next *>( this );

src/Parser/StatementNode.cc

@@ -54 +54 @@
                 StatementNode * nextStmt = new StatementNode(
                         new ast::DeclStmt( decl->location, maybeBuild( decl ) ) );
-                set_next( nextStmt );
-                if ( decl->get_next() ) {
-                        get_next()->set_next( new StatementNode( dynamic_cast< DeclarationNode * >(decl->get_next()) ) );
-                        decl->set_next( 0 );
+                next = nextStmt;
+                if ( decl->next ) {
+                        next->next = new StatementNode( decl->next );
+                        decl->next = nullptr;
                 } // if
         } else {
-                if ( decl->get_next() ) {
-                        set_next( new StatementNode( dynamic_cast< DeclarationNode * >( decl->get_next() ) ) );
-                        decl->set_next( 0 );
+                if ( decl->next ) {
+                        next = new StatementNode( decl->next );
+                        decl->next = nullptr;
                 } // if
                 agg = decl;
@@ -87 +87 @@
         ClauseNode * prev = this;
         // find end of list and maintain previous pointer
-        for ( ClauseNode * curr = prev; curr != nullptr; curr = (ClauseNode *)curr->get_next() ) {
-                ClauseNode * node = strict_dynamic_cast< ClauseNode * >(curr);
+        for ( ClauseNode * curr = prev; curr != nullptr; curr = curr->next ) {
+                ClauseNode * node = curr;
                 assert( dynamic_cast<ast::CaseClause *>( node->clause.get() ) );
                 prev = curr;
         } // for
-        ClauseNode * node = dynamic_cast< ClauseNode * >(prev);
+        ClauseNode * node = prev;
         // convert from StatementNode list to Statement list
         std::vector<ast::ptr<ast::Stmt>> stmts;
@@ -332 +332 @@
         clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
 
-        ExpressionNode * next = dynamic_cast<ExpressionNode *>( targetExpr->get_next() );
-        targetExpr->set_next( nullptr );
+        ExpressionNode * next = targetExpr->next;
+        targetExpr->next = nullptr;
         buildMoveList( next, clause->target_args );
 

src/Parser/TypeData.cc

@@ -494 +494 @@
         for ( auto i = outputList.begin() ;
                         i != outputList.end() ;
-                        ++i, n = (DeclarationNode*)n->get_next() ) {
+                        ++i, n = n->next ) {
                 // Only the object type class adds additional assertions.
                 if ( n->variable.tyClass != ast::TypeDecl::Otype ) {
@@ -639 +639 @@
         for ( auto i = outputForall.begin() ;
                         i != outputForall.end() ;
-                        ++i, n = (DeclarationNode*)n->get_next() ) {
+                        ++i, n = n->next ) {
                 // Only the object type class adds additional assertions.
                 if ( n->variable.tyClass != ast::TypeDecl::Otype ) {
@@ -1272 +1272 @@
         auto members = ret->members.begin();
         ret->hide = td->enumeration.hiding == EnumHiding::Hide ? ast::EnumDecl::EnumHiding::Hide : ast::EnumDecl::EnumHiding::Visible;
-        for ( const DeclarationNode * cur = td->enumeration.constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) {
+        for ( const DeclarationNode * cur = td->enumeration.constants; cur != nullptr; cur = cur->next, ++members ) {
                 if ( cur->enumInLine ) {
                         // Do Nothing
@@ -1500 +1500 @@
         assert( ! function.params );
         // loop over declaration first as it is easier to spot errors
-        for ( DeclarationNode * decl = function.oldDeclList; decl != nullptr; decl = dynamic_cast< DeclarationNode * >( decl->get_next() ) ) {
+        for ( DeclarationNode * decl = function.oldDeclList; decl != nullptr; decl = decl->next ) {
                 // scan ALL parameter names for each declaration name to check for duplicates
-                for ( DeclarationNode * param = function.idList; param != nullptr; param = dynamic_cast< DeclarationNode * >( param->get_next() ) ) {
+                for ( DeclarationNode * param = function.idList; param != nullptr; param = param->next ) {
                         if ( *decl->name == *param->name ) {
                                 // type set => parameter name already transformed by a declaration names so there is a duplicate
@@ -1524 +1524 @@
         //    rtb( a, b, c ) const char * b; {} => int rtn( int a, const char * b, int c ) {}
 
-        for ( DeclarationNode * param = function.idList; param != nullptr; param = dynamic_cast< DeclarationNode * >( param->get_next() ) ) {
+        for ( DeclarationNode * param = function.idList; param != nullptr; param = param->next ) {
                 if ( ! param->type ) {                                                  // generate type int for empty parameter type
                         param->type = new TypeData( TypeData::Basic );

src/Parser/parser.yy

@@ -127 +127 @@
 
         // Start at second variable in declaration list and clone the type specifiers for each variable.
-        for ( DeclarationNode * cur = dynamic_cast<DeclarationNode *>( declList->get_next() ); cur != nullptr; cur = dynamic_cast<DeclarationNode *>( cur->get_next() ) ) {
+        for ( DeclarationNode * cur = declList->next ; cur != nullptr; cur = cur->next ) {
                 cl->cloneBaseType( cur, copyattr );                             // cur is modified
         } // for
@@ -139 +139 @@
 void distExt( DeclarationNode * declaration ) {
         // distribute EXTENSION across all declarations
-        for ( DeclarationNode *iter = declaration; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
+        for ( DeclarationNode *iter = declaration ; iter != nullptr ; iter = iter->next ) {
                 iter->set_extension( true );
         } // for
@@ -146 +146 @@
 void distInl( DeclarationNode * declaration ) {
         // distribute INLINE across all declarations
-        for ( DeclarationNode *iter = declaration; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
+        for ( DeclarationNode *iter = declaration ; iter != nullptr ; iter = iter->next ) {
                 iter->set_inLine( true );
         } // for
@@ -153 +153 @@
 void distQual( DeclarationNode * declaration, DeclarationNode * qualifiers ) {
         // distribute qualifiers across all non-variable declarations in a distribution statemement
-        for ( DeclarationNode * iter = declaration; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
+        for ( DeclarationNode * iter = declaration ; iter != nullptr ; iter = iter->next ) {
                 // SKULLDUGGERY: Distributions are parsed inside out, so qualifiers are added to declarations inside out. Since
                 // addQualifiers appends to the back of the list, the forall clauses are in the wrong order (right to left). To