Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision c468150098b8a4da2737fa32e27d1f9bf6a0c179) +++ src/Parser/DeclarationNode.cc (revision 661117761e1e429d1007ea57fa382fed68089100) @@ -1003,5 +1003,5 @@ } -void buildList( const DeclarationNode * firstNode, +void buildList( DeclarationNode * firstNode, std::vector> & outputList ) { SemanticErrorException errors; @@ -1136,5 +1136,5 @@ // currently only builds assertions, function parameters, and return values -void buildList( const DeclarationNode * firstNode, std::vector> & outputList ) { +void buildList( DeclarationNode * firstNode, std::vector> & outputList ) { SemanticErrorException errors; std::back_insert_iterator>> out( outputList ); Index: src/Parser/DeclarationNode.h =================================================================== --- src/Parser/DeclarationNode.h (revision c468150098b8a4da2737fa32e27d1f9bf6a0c179) +++ src/Parser/DeclarationNode.h (revision 661117761e1e429d1007ea57fa382fed68089100) @@ -180,9 +180,9 @@ template class Container, typename... Args> -void buildList( const NodeType * firstNode, +void buildList( NodeType * firstNode, Container, Args...> & output ) { SemanticErrorException errors; std::back_insert_iterator, Args...>> out( output ); - const NodeType * cur = firstNode; + NodeType * cur = firstNode; while ( cur ) { @@ -197,7 +197,7 @@ errors.append( e ); } // try - const ParseNode * temp = cur->get_next(); + ParseNode * temp = cur->get_next(); // Should not return nullptr, then it is non-homogeneous: - cur = dynamic_cast( temp ); + cur = dynamic_cast( temp ); if ( !cur && temp ) { SemanticError( temp->location, "internal error, non-homogeneous nodes founds in buildList processing." ); @@ -209,13 +209,13 @@ } -void buildList( const DeclarationNode * firstNode, std::vector> & outputList ); -void buildList( const DeclarationNode * firstNode, std::vector> & outputList ); +void buildList( DeclarationNode * firstNode, std::vector> & outputList ); +void buildList( DeclarationNode * firstNode, std::vector> & outputList ); void buildTypeList( const DeclarationNode * firstNode, std::vector> & outputList ); template class Container, typename... Args> -void buildMoveList( const NodeType * firstNode, -Container, Args...> & output ) { -buildList( firstNode, output ); -delete firstNode; +void buildMoveList( NodeType * firstNode, + Container, Args...> & output ) { + buildList( firstNode, output ); + delete firstNode; } Index: src/Parser/ExpressionNode.cc =================================================================== --- src/Parser/ExpressionNode.cc (revision c468150098b8a4da2737fa32e27d1f9bf6a0c179) +++ src/Parser/ExpressionNode.cc (revision 661117761e1e429d1007ea57fa382fed68089100) @@ -702,11 +702,4 @@ } // build_binary_val -ast::Expr * build_binary_ptr( const CodeLocation & location, - OperKinds op, - ExpressionNode * expr_node1, - ExpressionNode * expr_node2 ) { - return build_binary_val( location, op, expr_node1, expr_node2 ); -} // build_binary_ptr - ast::Expr * build_cond( const CodeLocation & location, ExpressionNode * expr_node1, Index: src/Parser/ExpressionNode.h =================================================================== --- src/Parser/ExpressionNode.h (revision c468150098b8a4da2737fa32e27d1f9bf6a0c179) +++ src/Parser/ExpressionNode.h (revision 661117761e1e429d1007ea57fa382fed68089100) @@ -41,6 +41,6 @@ bool isExpressionType() const { return nullptr != dynamic_cast(expr.get()); } - ast::Expr * build() const { - ast::Expr * node = const_cast(this)->expr.release(); + ast::Expr * build() { + ast::Expr * node = expr.release(); node->set_extension( this->get_extension() ); node->location = this->location; @@ -53,24 +53,4 @@ bool extension = false; }; // ExpressionNode - -/* -// Must harmonize with OperName. -enum class OperKinds { - // diadic - SizeOf, AlignOf, OffsetOf, Plus, Minus, Exp, Mul, Div, Mod, Or, And, - BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq, - Assign, AtAssn, ExpAssn, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn, - Index, Range, - // monadic - UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, - Ctor, Dtor, -}; // OperKinds - -enum class EnumHiding { Visible, Hide }; - -struct LabelNode { - std::vector labels; -}; -*/ // These 4 routines modify the string: @@ -99,5 +79,4 @@ ast::Expr * build_unary_val( const CodeLocation &, OperKinds op, ExpressionNode * expr_node ); ast::Expr * build_binary_val( const CodeLocation &, OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ); -ast::Expr * build_binary_ptr( const CodeLocation &, OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ); ast::Expr * build_cond( const CodeLocation &, ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 ); ast::Expr * build_tuple( const CodeLocation &, ExpressionNode * expr_node = nullptr ); Index: src/Parser/StatementNode.cc =================================================================== --- src/Parser/StatementNode.cc (revision c468150098b8a4da2737fa32e27d1f9bf6a0c179) +++ src/Parser/StatementNode.cc (revision 661117761e1e429d1007ea57fa382fed68089100) @@ -11,6 +11,6 @@ // Created On : Sat May 16 14:59:41 2015 // Last Modified By : Andrew Beach -// Last Modified On : Tue Apr 4 11:40:00 2023 -// Update Count : 427 +// Last Modified On : Tue Apr 11 10:16:00 2023 +// Update Count : 428 // @@ -32,4 +32,19 @@ using namespace std; + +// Some helpers for cases that really want a single node but check for lists. +static const ast::Stmt * buildMoveSingle( StatementNode * node ) { + std::vector> list; + buildMoveList( node, list ); + assertf( list.size() == 1, "CFA Internal Error: Extra/Missing Nodes" ); + return list.front().release(); +} + +static const ast::Stmt * buildMoveOptional( StatementNode * node ) { + std::vector> list; + buildMoveList( node, list ); + assertf( list.size() <= 1, "CFA Internal Error: Extra Nodes" ); + return list.empty() ? nullptr : list.front().release(); +} StatementNode::StatementNode( DeclarationNode * decl ) { @@ -69,15 +84,14 @@ } -StatementNode * StatementNode::append_last_case( StatementNode * stmt ) { - StatementNode * prev = this; +ClauseNode * ClauseNode::append_last_case( StatementNode * stmt ) { + ClauseNode * prev = this; // find end of list and maintain previous pointer - for ( StatementNode * curr = prev; curr != nullptr; curr = (StatementNode *)curr->get_next() ) { - StatementNode * node = strict_dynamic_cast< StatementNode * >(curr); - assert( nullptr == node->stmt.get() ); + for ( ClauseNode * curr = prev; curr != nullptr; curr = (ClauseNode *)curr->get_next() ) { + ClauseNode * node = strict_dynamic_cast< ClauseNode * >(curr); assert( dynamic_cast( node->clause.get() ) ); prev = curr; } // for + ClauseNode * node = dynamic_cast< ClauseNode * >(prev); // convert from StatementNode list to Statement list - StatementNode * node = dynamic_cast< StatementNode * >(prev); std::vector> stmts; buildMoveList( stmt, stmts ); @@ -89,5 +103,5 @@ stmts.clear(); return this; -} // StatementNode::append_last_case +} // ClauseNode::append_last_case ast::Stmt * build_expr( CodeLocation const & location, ExpressionNode * ctl ) { @@ -113,7 +127,5 @@ for ( ast::ptr & stmt : inits ) { // build the && of all of the declared variables compared against 0 - //auto declStmt = strict_dynamic_cast( stmt ); auto declStmt = stmt.strict_as(); - //ast::DeclWithType * dwt = strict_dynamic_cast( declStmt->decl ); auto dwt = declStmt->decl.strict_as(); ast::Expr * nze = notZeroExpr( new ast::VariableExpr( dwt->location, dwt ) ); @@ -136,8 +148,5 @@ ast::Stmt const * astelse = nullptr; if ( else_ ) { - std::vector> aststmt; - buildMoveList( else_, aststmt ); - assert( aststmt.size() == 1 ); - astelse = aststmt.front().release(); + astelse = buildMoveSingle( else_ ); } // if @@ -147,42 +156,7 @@ } // build_if -// Temporary work around. Split StmtClause off from StatementNode. -template -static void buildMoveClauseList( StatementNode * firstNode, - std::vector> & output ) { - SemanticErrorException errors; - std::back_insert_iterator>> - out( output ); - StatementNode * cur = firstNode; - - while ( cur ) { - try { - auto clause = cur->clause.release(); - if ( auto result = dynamic_cast( clause ) ) { - *out++ = result; - } else { - assertf(false, __PRETTY_FUNCTION__ ); - SemanticError( cur->location, "type specifier declaration in forall clause is currently unimplemented." ); - } // if - } catch( SemanticErrorException & e ) { - errors.append( e ); - } // try - ParseNode * temp = cur->get_next(); - // Should not return nullptr, then it is non-homogeneous: - cur = dynamic_cast( temp ); - if ( !cur && temp ) { - SemanticError( temp->location, "internal error, non-homogeneous nodes founds in buildList processing." ); - } // if - } // while - if ( ! errors.isEmpty() ) { - throw errors; - } // if - // Usually in the wrapper. - delete firstNode; -} - -ast::Stmt * build_switch( const CodeLocation & location, bool isSwitch, ExpressionNode * ctl, StatementNode * stmt ) { +ast::Stmt * build_switch( const CodeLocation & location, bool isSwitch, ExpressionNode * ctl, ClauseNode * stmt ) { std::vector> aststmt; - buildMoveClauseList( stmt, aststmt ); + buildMoveList( stmt, aststmt ); // If it is not a switch it is a choose statement. if ( ! isSwitch ) { @@ -206,8 +180,8 @@ } // build_switch -ast::CaseClause * build_case( ExpressionNode * ctl ) { +ast::CaseClause * build_case( const CodeLocation & location, ExpressionNode * ctl ) { // stmt starts empty and then added to auto expr = maybeMoveBuild( ctl ); - return new ast::CaseClause( expr->location, expr, {} ); + return new ast::CaseClause( location, expr, {} ); } // build_case @@ -221,16 +195,8 @@ ast::Expr * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set - std::vector> aststmt; // loop body, compound created if empty - buildMoveList( stmt, aststmt ); - assert( aststmt.size() == 1 ); - - std::vector> astelse; // else clause, maybe empty - buildMoveList( else_, astelse ); - assert( astelse.size() <= 1 ); - return new ast::WhileDoStmt( location, astcond, - aststmt.front(), - astelse.empty() ? nullptr : astelse.front().release(), + buildMoveSingle( stmt ), + buildMoveOptional( else_ ), std::move( astinit ), ast::While @@ -239,17 +205,9 @@ ast::Stmt * build_do_while( const CodeLocation & location, ExpressionNode * ctl, StatementNode * stmt, StatementNode * else_ ) { - std::vector> aststmt; // loop body, compound created if empty - buildMoveList( stmt, aststmt ); - assert( aststmt.size() == 1 ); // compound created if empty - - std::vector> astelse; // else clause, maybe empty - buildMoveList( else_, astelse ); - assert( astelse.size() <= 1 ); - // do-while cannot have declarations in the contitional, so init is always empty return new ast::WhileDoStmt( location, notZeroExpr( maybeMoveBuild( ctl ) ), - aststmt.front(), - astelse.empty() ? nullptr : astelse.front().release(), + buildMoveSingle( stmt ), + buildMoveOptional( else_ ), {}, ast::DoWhile @@ -267,12 +225,4 @@ astincr = maybeMoveBuild( forctl->change ); delete forctl; - - std::vector> aststmt; // loop body, compound created if empty - buildMoveList( stmt, aststmt ); - assert( aststmt.size() == 1 ); - - std::vector> astelse; // else clause, maybe empty - buildMoveList( else_, astelse ); - assert( astelse.size() <= 1 ); return new ast::ForStmt( location, @@ -280,6 +230,6 @@ astcond, astincr, - aststmt.front(), - astelse.empty() ? nullptr : astelse.front().release() + buildMoveSingle( stmt ), + buildMoveOptional( else_ ) ); } // build_for @@ -342,7 +292,7 @@ } // build_resume_at -ast::Stmt * build_try( const CodeLocation & location, StatementNode * try_, StatementNode * catch_, StatementNode * finally_ ) { +ast::Stmt * build_try( const CodeLocation & location, StatementNode * try_, ClauseNode * catch_, ClauseNode * finally_ ) { std::vector> aststmt; - buildMoveClauseList( catch_, aststmt ); + buildMoveList( catch_, aststmt ); ast::CompoundStmt * tryBlock = strict_dynamic_cast( maybeMoveBuild( try_ ) ); ast::FinallyClause * finallyBlock = nullptr; @@ -358,33 +308,27 @@ ast::CatchClause * build_catch( const CodeLocation & location, ast::ExceptionKind kind, DeclarationNode * decl, ExpressionNode * cond, StatementNode * body ) { - std::vector> aststmt; - buildMoveList( body, aststmt ); - assert( aststmt.size() == 1 ); return new ast::CatchClause( location, kind, maybeMoveBuild( decl ), maybeMoveBuild( cond ), - aststmt.front().release() + buildMoveSingle( body ) ); } // build_catch ast::FinallyClause * build_finally( const CodeLocation & location, StatementNode * stmt ) { - std::vector> aststmt; - buildMoveList( stmt, aststmt ); - assert( aststmt.size() == 1 ); return new ast::FinallyClause( location, - aststmt.front().strict_as() + strict_dynamic_cast( + buildMoveSingle( stmt ) + ) ); } // build_finally ast::SuspendStmt * build_suspend( const CodeLocation & location, StatementNode * then, ast::SuspendStmt::Kind kind ) { - std::vector> stmts; - buildMoveList( then, stmts ); - ast::CompoundStmt const * then2 = nullptr; - if(!stmts.empty()) { - assert( stmts.size() == 1 ); - then2 = stmts.front().strict_as(); - } - return new ast::SuspendStmt( location, then2, kind ); + return new ast::SuspendStmt( location, + strict_dynamic_cast( + buildMoveOptional( then ) + ), + kind + ); } // build_suspend Index: src/Parser/StatementNode.h =================================================================== --- src/Parser/StatementNode.h (revision c468150098b8a4da2737fa32e27d1f9bf6a0c179) +++ src/Parser/StatementNode.h (revision 661117761e1e429d1007ea57fa382fed68089100) @@ -10,6 +10,6 @@ // Created On : Wed Apr 5 11:42:00 2023 // Last Modified By : Andrew Beach -// Last Modified On : Wed Apr 5 11:57:00 2023 -// Update Count : 0 +// Last Modified On : Tue Apr 11 9:43:00 2023 +// Update Count : 1 // @@ -19,30 +19,16 @@ struct StatementNode final : public ParseNode { - StatementNode() : - stmt( nullptr ), clause( nullptr ) {} - StatementNode( ast::Stmt * stmt ) : - stmt( stmt ), clause( nullptr ) {} - StatementNode( ast::StmtClause * clause ) : - stmt( nullptr ), clause( clause ) {} + StatementNode() : stmt( nullptr ) {} + StatementNode( ast::Stmt * stmt ) : stmt( stmt ) {} StatementNode( DeclarationNode * decl ); virtual ~StatementNode() {} virtual StatementNode * clone() const final { assert( false ); return nullptr; } - ast::Stmt * build() const { return const_cast(this)->stmt.release(); } + ast::Stmt * build() { return stmt.release(); } StatementNode * add_label( const CodeLocation & location, const std::string * name, - DeclarationNode * attr = nullptr );/* { - stmt->labels.emplace_back( location, - *name, - attr ? std::move( attr->attributes ) - : std::vector>{} ); - delete attr; - delete name; - return this; - }*/ - - virtual StatementNode * append_last_case( StatementNode * ); + DeclarationNode * attr = nullptr ); virtual void print( std::ostream & os, __attribute__((unused)) int indent = 0 ) const override { @@ -51,6 +37,22 @@ std::unique_ptr stmt; +}; // StatementNode + +struct ClauseNode final : public ParseNode { + ClauseNode( ast::StmtClause * clause ) : clause( clause ) {} + virtual ~ClauseNode() {} + + ClauseNode * set_last( ParseNode * newlast ) { + ParseNode::set_last( newlast ); + return this; + } + + virtual ClauseNode * clone() const final { assert( false ); return nullptr; } + ast::StmtClause * build() { return clause.release(); } + + virtual ClauseNode * append_last_case( StatementNode * ); + std::unique_ptr clause; -}; // StatementNode +}; ast::Stmt * build_expr( CodeLocation const &, ExpressionNode * ctl ); @@ -74,6 +76,6 @@ ast::Stmt * build_if( const CodeLocation &, CondCtl * ctl, StatementNode * then, StatementNode * else_ ); -ast::Stmt * build_switch( const CodeLocation &, bool isSwitch, ExpressionNode * ctl, StatementNode * stmt ); -ast::CaseClause * build_case( ExpressionNode * ctl ); +ast::Stmt * build_switch( const CodeLocation &, bool isSwitch, ExpressionNode * ctl, ClauseNode * stmt ); +ast::CaseClause * build_case( const CodeLocation &, ExpressionNode * ctl ); ast::CaseClause * build_default( const CodeLocation & ); ast::Stmt * build_while( const CodeLocation &, CondCtl * ctl, StatementNode * stmt, StatementNode * else_ = nullptr ); @@ -87,5 +89,5 @@ ast::Stmt * build_resume( const CodeLocation &, ExpressionNode * ctl ); ast::Stmt * build_resume_at( ExpressionNode * ctl , ExpressionNode * target ); -ast::Stmt * build_try( const CodeLocation &, StatementNode * try_, StatementNode * catch_, StatementNode * finally_ ); +ast::Stmt * build_try( const CodeLocation &, StatementNode * try_, ClauseNode * catch_, ClauseNode * finally_ ); ast::CatchClause * build_catch( const CodeLocation &, ast::ExceptionKind kind, DeclarationNode * decl, ExpressionNode * cond, StatementNode * body ); ast::FinallyClause * build_finally( const CodeLocation &, StatementNode * stmt ); Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision c468150098b8a4da2737fa32e27d1f9bf6a0c179) +++ src/Parser/parser.yy (revision 661117761e1e429d1007ea57fa382fed68089100) @@ -306,4 +306,5 @@ ast::TypeDecl::Kind tclass; StatementNode * sn; + ClauseNode * clause; ast::WaitForStmt * wfs; ast::Expr * constant; @@ -416,12 +417,13 @@ %type statement_decl statement_decl_list statement_list_nodecl %type selection_statement if_statement -%type switch_clause_list_opt switch_clause_list +%type switch_clause_list_opt switch_clause_list %type case_value -%type case_clause case_value_list case_label case_label_list +%type case_clause case_value_list case_label case_label_list %type iteration_statement jump_statement %type expression_statement asm_statement %type with_statement %type with_clause_opt -%type exception_statement handler_clause finally_clause +%type exception_statement +%type handler_clause finally_clause %type handler_key %type mutex_statement @@ -1261,7 +1263,7 @@ case_value_list: // CFA - case_value { $$ = new StatementNode( build_case( $1 ) ); } + case_value { $$ = new ClauseNode( build_case( yylloc, $1 ) ); } // convert case list, e.g., "case 1, 3, 5:" into "case 1: case 3: case 5" - | case_value_list ',' case_value { $$ = (StatementNode *)($1->set_last( new StatementNode( build_case( $3 ) ) ) ); } + | case_value_list ',' case_value { $$ = $1->set_last( new ClauseNode( build_case( yylloc, $3 ) ) ); } ; @@ -1272,5 +1274,5 @@ | CASE case_value_list error // syntax error { SemanticError( yylloc, "Missing colon after case list." ); $$ = nullptr; } - | DEFAULT ':' { $$ = new StatementNode( build_default( yylloc ) ); } + | DEFAULT ':' { $$ = new ClauseNode( build_default( yylloc ) ); } // A semantic check is required to ensure only one default clause per switch/choose statement. | DEFAULT error // syntax error @@ -1280,5 +1282,5 @@ case_label_list: // CFA case_label - | case_label_list case_label { $$ = (StatementNode *)( $1->set_last( $2 )); } + | case_label_list case_label { $$ = $1->set_last( $2 ); } ; @@ -1297,5 +1299,5 @@ { $$ = $1->append_last_case( new StatementNode( build_compound( yylloc, $2 ) ) ); } | switch_clause_list case_label_list statement_list_nodecl - { $$ = (StatementNode *)( $1->set_last( $2->append_last_case( new StatementNode( build_compound( yylloc, $3 ) ) ) ) ); } + { $$ = $1->set_last( $2->append_last_case( new StatementNode( build_compound( yylloc, $3 ) ) ) ); } ; @@ -1731,7 +1733,7 @@ handler_clause: handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement - { $$ = new StatementNode( build_catch( yylloc, $1, $4, $6, $8 ) ); } + { $$ = new ClauseNode( build_catch( yylloc, $1, $4, $6, $8 ) ); } | handler_clause handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement - { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( yylloc, $2, $5, $7, $9 ) ) ); } + { $$ = $1->set_last( new ClauseNode( build_catch( yylloc, $2, $5, $7, $9 ) ) ); } ; @@ -1750,5 +1752,5 @@ finally_clause: - FINALLY compound_statement { $$ = new StatementNode( build_finally( yylloc, $2 ) ); } + FINALLY compound_statement { $$ = new ClauseNode( build_finally( yylloc, $2 ) ); } ; Index: src/Parser/parserutility.h =================================================================== --- src/Parser/parserutility.h (revision c468150098b8a4da2737fa32e27d1f9bf6a0c179) +++ src/Parser/parserutility.h (revision 661117761e1e429d1007ea57fa382fed68089100) @@ -24,10 +24,10 @@ template< typename T > -static inline auto maybeBuild( const T *orig ) -> decltype(orig->build()) { +static inline auto maybeBuild( T * orig ) -> decltype(orig->build()) { return (orig) ? orig->build() : nullptr; } template< typename T > -static inline auto maybeMoveBuild( const T *orig ) -> decltype(orig->build()) { +static inline auto maybeMoveBuild( T * orig ) -> decltype(orig->build()) { auto ret = maybeBuild(orig); delete orig;