Changeset b110bcc for src/Parser/InitializerNode.cc

Timestamp:

Apr 21, 2023, 5:36:12 PM (2 years ago)

Author:

JiadaL <j82liang@…>

Branches:

ADT, master

Children:

28f8f15, 6e4c44d

Parents:

2ed94a9 (diff), 699a97d (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/Parser/InitializerNode.cc (modified) (4 diffs)

src/Parser/InitializerNode.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:20:24 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jul 28 23:27:20 2017
-// Update Count     : 26
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Apr  4 11:18:00 2023
+// Update Count     : 27
 //
+
+#include "InitializerNode.h"
 
 #include <iostream>                // for operator<<, ostream, basic_ostream
@@ -18 +20 @@
 #include <string>                  // for operator<<, string
 
+#include "AST/Expr.hpp"            // for Expr
+#include "AST/Init.hpp"            // for Designator, Init, ListInit, Sing...
+#include "Common/SemanticError.h"  // for SemanticError
+#include "Common/utility.h"        // for maybeBuild
+#include "ExpressionNode.h"        // for ExpressionNode
+#include "DeclarationNode.h"       // for buildList
+
 using namespace std;
 
-#include "Common/SemanticError.h"  // for SemanticError
-#include "Common/utility.h"        // for maybeBuild
-#include "ParseNode.h"             // for InitializerNode, ExpressionNode
-#include "SynTree/Expression.h"    // for Expression
-#include "SynTree/Initializer.h"   // for Initializer, ListInit, SingleInit
+static ast::ConstructFlag toConstructFlag( bool maybeConstructed ) {
+        return maybeConstructed ? ast::MaybeConstruct : ast::NoConstruct;
+}
 
 InitializerNode::InitializerNode( ExpressionNode * _expr, bool aggrp, ExpressionNode * des )
@@ -33 +40 @@
         if ( kids )
                 set_last( nullptr );
-} // InitializerNode::InitializerNode
+} // InitializerNode::InitializerNode
 
 InitializerNode::InitializerNode( InitializerNode * init, bool aggrp, ExpressionNode * des )
@@ -85 +92 @@
 } // InitializerNode::printOneLine
 
-Initializer * InitializerNode::build() const {
+ast::Init * InitializerNode::build() const {
         assertf( ! isDelete, "Should not build delete stmt InitializerNode" );
         if ( aggregate ) {
                 // steal designators from children
-                std::list< Designation * > designlist;
+                std::vector<ast::ptr<ast::Designation>> designlist;
                 InitializerNode * child = next_init();
-                for ( ; child != nullptr; child = dynamic_cast< InitializerNode * >( child->get_next() ) ) {
-                        std::list< Expression * > desList;
-                        buildList< Expression, ExpressionNode >( child->designator, desList );
-                        designlist.push_back( new Designation( desList ) );
+                for ( ; child != nullptr ; child = dynamic_cast< InitializerNode * >( child->get_next() ) ) {
+                        std::deque<ast::ptr<ast::Expr>> desList;
+                        buildList( child->designator, desList );
+                        designlist.push_back(
+                                new ast::Designation( location, std::move( desList ) ) );
                 } // for
-                std::list< Initializer * > initlist;
-                buildList< Initializer, InitializerNode >( next_init(), initlist );
-                return new ListInit( initlist, designlist, maybeConstructed );
-        } else {
-                if ( get_expression() ) {
-                        assertf( get_expression()->expr, "The expression of initializer must have value" );
-                        return new SingleInit( maybeBuild< Expression >( get_expression() ), maybeConstructed );
-                } // if
+                std::vector<ast::ptr<ast::Init>> initlist;
+                buildList( next_init(), initlist );
+                return new ast::ListInit( location,
+                        std::move( initlist ),
+                        std::move( designlist ),
+                        toConstructFlag( maybeConstructed )
+                );
+        } else if ( get_expression() ) {
+                assertf( get_expression()->expr, "The expression of initializer must have value" );
+                return new ast::SingleInit( location,
+                        maybeBuild( get_expression() ),
+                        toConstructFlag( maybeConstructed )
+                );
         } // if
         return nullptr;