Changeset 5bf685f for src/Parser

Timestamp:

Jan 17, 2024, 3:13:56 PM (5 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

11f65b3

Parents:

e891349

Message:

Replayed maybeClone with maybeCopy, removed unused helppers in utility.h and pushed some includes out of headers.

Location:

src/Parser

Files:

• DeclarationNode.cc (modified) (9 diffs)
• ParseNode.h (modified) (1 diff)
• TypeData.cc (modified) (5 diffs)
• parser.yy (modified) (1 diff)
• parserutility.h (modified) (1 diff)

src/Parser/DeclarationNode.cc

@@ -35 +35 @@
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/UniqueName.h"     // for UniqueName
-#include "Common/utility.h"        // for maybeClone
+#include "Common/utility.h"        // for copy, spliceBegin
 #include "Parser/ExpressionNode.h" // for ExpressionNode
 #include "Parser/InitializerNode.h"// for InitializerNode
@@ -41 +41 @@
 #include "TypeData.h"              // for TypeData, TypeData::Aggregate_t
 #include "TypedefTable.h"          // for TypedefTable
-
-class Initializer;
 
 extern TypedefTable typedefTable;
@@ -101 +99 @@
 DeclarationNode * DeclarationNode::clone() const {
         DeclarationNode * newnode = new DeclarationNode;
-        newnode->set_next( maybeClone( get_next() ) );
+        newnode->set_next( maybeCopy( get_next() ) );
         newnode->name = name ? new string( *name ) : nullptr;
 
         newnode->builtin = NoBuiltinType;
-        newnode->type = maybeClone( type );
+        newnode->type = maybeCopy( type );
         newnode->inLine = inLine;
         newnode->storageClasses = storageClasses;
         newnode->funcSpecs = funcSpecs;
-        newnode->bitfieldWidth = maybeClone( bitfieldWidth );
-        newnode->enumeratorValue.reset( maybeClone( enumeratorValue.get() ) );
+        newnode->bitfieldWidth = maybeCopy( bitfieldWidth );
+        newnode->enumeratorValue.reset( maybeCopy( enumeratorValue.get() ) );
         newnode->hasEllipsis = hasEllipsis;
         newnode->linkage = linkage;
         newnode->asmName = maybeCopy( asmName );
         newnode->attributes = attributes;
-        newnode->initializer = maybeClone( initializer );
+        newnode->initializer = maybeCopy( initializer );
         newnode->extension = extension;
-        newnode->asmStmt = maybeClone( asmStmt );
+        newnode->asmStmt = maybeCopy( asmStmt );
         newnode->error = error;
 
 //      newnode->variable.name = variable.name ? new string( *variable.name ) : nullptr;
         newnode->variable.tyClass = variable.tyClass;
-        newnode->variable.assertions = maybeClone( variable.assertions );
-        newnode->variable.initializer = maybeClone( variable.initializer );
-
-        newnode->assert.condition = maybeClone( assert.condition );
+        newnode->variable.assertions = maybeCopy( variable.assertions );
+        newnode->variable.initializer = maybeCopy( variable.initializer );
+
+        newnode->assert.condition = maybeCopy( assert.condition );
         newnode->assert.message = maybeCopy( assert.message );
         return newnode;
@@ -664 +662 @@
                                 dst->base->aggInst.aggregate = src;
                                 if ( src->kind == TypeData::Aggregate ) {
-                                        dst->base->aggInst.params = maybeClone( src->aggregate.actuals );
+                                        dst->base->aggInst.params = maybeCopy( src->aggregate.actuals );
                                 } // if
                                 dst->base->qualifiers |= src->qualifiers;
@@ -694 +692 @@
                                         if ( o->type->kind == TypeData::Aggregate ) {
                                                 type->aggInst.hoistType = o->type->aggregate.body;
-                                                type->aggInst.params = maybeClone( o->type->aggregate.actuals );
+                                                type->aggInst.params = maybeCopy( o->type->aggregate.actuals );
                                         } else {
                                                 type->aggInst.hoistType = o->type->enumeration.body;
@@ -860 +858 @@
                                 p->type->base->aggInst.aggregate = type;
                                 if ( type->kind == TypeData::Aggregate ) {
-                                        p->type->base->aggInst.params = maybeClone( type->aggregate.actuals );
+                                        p->type->base->aggInst.params = maybeCopy( type->aggregate.actuals );
                                 } // if
                                 p->type->base->qualifiers |= type->qualifiers;
@@ -897 +895 @@
                         lastArray->base->aggInst.aggregate = type;
                         if ( type->kind == TypeData::Aggregate ) {
-                                lastArray->base->aggInst.params = maybeClone( type->aggregate.actuals );
+                                lastArray->base->aggInst.params = maybeCopy( type->aggregate.actuals );
                         } // if
                         lastArray->base->qualifiers |= type->qualifiers;
@@ -950 +948 @@
 DeclarationNode * DeclarationNode::cloneType( string * name ) {
         DeclarationNode * newnode = newName( name );
-        newnode->type = maybeClone( type );
+        newnode->type = maybeCopy( type );
         newnode->copySpecifiers( this );
         return newnode;
@@ -984 +982 @@
                 } // if
 
-                newType->forall = maybeClone( type->forall );
+                newType->forall = maybeCopy( type->forall );
                 if ( ! o->type ) {
                         o->type = newType;

src/Parser/ParseNode.h

@@ -30 +30 @@
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/UniqueName.h"     // for UniqueName
-#include "Common/utility.h"        // for maybeClone
 #include "Parser/parserutility.h"  // for maybeBuild, maybeCopy
 

src/Parser/TypeData.cc

@@ -167 +167 @@
         TypeData * newtype = new TypeData( kind );
         newtype->qualifiers = qualifiers;
-        newtype->base = maybeClone( base );
-        newtype->forall = maybeClone( forall );
+        newtype->base = maybeCopy( base );
+        newtype->forall = maybeCopy( forall );
 
         switch ( kind ) {
@@ -185 +185 @@
                 break;
         case Array:
-                newtype->array.dimension = maybeClone( array.dimension );
+                newtype->array.dimension = maybeCopy( array.dimension );
                 newtype->array.isVarLen = array.isVarLen;
                 newtype->array.isStatic = array.isStatic;
                 break;
         case Function:
-                newtype->function.params = maybeClone( function.params );
-                newtype->function.idList = maybeClone( function.idList );
-                newtype->function.oldDeclList = maybeClone( function.oldDeclList );
-                newtype->function.body = maybeClone( function.body );
-                newtype->function.withExprs = maybeClone( function.withExprs );
+                newtype->function.params = maybeCopy( function.params );
+                newtype->function.idList = maybeCopy( function.idList );
+                newtype->function.oldDeclList = maybeCopy( function.oldDeclList );
+                newtype->function.body = maybeCopy( function.body );
+                newtype->function.withExprs = maybeCopy( function.withExprs );
                 break;
         case Aggregate:
                 newtype->aggregate.kind = aggregate.kind;
                 newtype->aggregate.name = aggregate.name ? new string( *aggregate.name ) : nullptr;
-                newtype->aggregate.params = maybeClone( aggregate.params );
-                newtype->aggregate.actuals = maybeClone( aggregate.actuals );
-                newtype->aggregate.fields = maybeClone( aggregate.fields );
+                newtype->aggregate.params = maybeCopy( aggregate.params );
+                newtype->aggregate.actuals = maybeCopy( aggregate.actuals );
+                newtype->aggregate.fields = maybeCopy( aggregate.fields );
                 newtype->aggregate.body = aggregate.body;
                 newtype->aggregate.anon = aggregate.anon;
@@ -208 +208 @@
                 break;
         case AggregateInst:
-                newtype->aggInst.aggregate = maybeClone( aggInst.aggregate );
-                newtype->aggInst.params = maybeClone( aggInst.params );
+                newtype->aggInst.aggregate = maybeCopy( aggInst.aggregate );
+                newtype->aggInst.params = maybeCopy( aggInst.params );
                 newtype->aggInst.hoistType = aggInst.hoistType;
                 break;
         case Enum:
                 newtype->enumeration.name = enumeration.name ? new string( *enumeration.name ) : nullptr;
-                newtype->enumeration.constants = maybeClone( enumeration.constants );
+                newtype->enumeration.constants = maybeCopy( enumeration.constants );
                 newtype->enumeration.body = enumeration.body;
                 newtype->enumeration.anon = enumeration.anon;
@@ -221 +221 @@
         case SymbolicInst:
                 newtype->symbolic.name = symbolic.name ? new string( *symbolic.name ) : nullptr;
-                newtype->symbolic.params = maybeClone( symbolic.params );
-                newtype->symbolic.actuals = maybeClone( symbolic.actuals );
-                newtype->symbolic.assertions = maybeClone( symbolic.assertions );
+                newtype->symbolic.params = maybeCopy( symbolic.params );
+                newtype->symbolic.actuals = maybeCopy( symbolic.actuals );
+                newtype->symbolic.assertions = maybeCopy( symbolic.assertions );
                 newtype->symbolic.isTypedef = symbolic.isTypedef;
                 break;
         case Tuple:
-                newtype->tuple = maybeClone( tuple );
+                newtype->tuple = maybeCopy( tuple );
                 break;
         case Typeof:
         case Basetypeof:
-                newtype->typeexpr = maybeClone( typeexpr );
+                newtype->typeexpr = maybeCopy( typeexpr );
                 break;
         case Vtable:
@@ -240 +240 @@
                 break;
         case Qualified:
-                newtype->qualified.parent = maybeClone( qualified.parent );
-                newtype->qualified.child = maybeClone( qualified.child );
+                newtype->qualified.parent = maybeCopy( qualified.parent );
+                newtype->qualified.child = maybeCopy( qualified.child );
                 break;
         } // switch

src/Parser/parser.yy

@@ -1960 +1960 @@
                         // Append the return type at the start (left-hand-side) to each identifier in the list.
                         DeclarationNode * ret = new DeclarationNode;
-                        ret->type = maybeClone( $1->type->base );
+                        ret->type = maybeCopy( $1->type->base );
                         $$ = $1->appendList( DeclarationNode::newFunction( $3, ret, $6, nullptr ) );
                 }

src/Parser/parserutility.h

@@ -36 +36 @@
 
 template<typename node_t>
-node_t * maybeCopy( node_t const * node ) {
+static inline node_t * maybeCopy( node_t const * node ) {
         return node ? ast::shallowCopy( node ) : nullptr;
 }