Changeset c84dd61 for src/Parser

Timestamp:

Jun 21, 2023, 2:38:55 AM (17 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

92355883

Parents:

0b0a285 (diff), 2de175ce (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

Location:

src/Parser

Files:

• DeclarationNode.cc (modified) (7 diffs)
• ExpressionNode.cc (modified) (2 diffs)
• ExpressionNode.h (modified) (1 diff)
• parser.yy (modified) (3 diffs)

src/Parser/DeclarationNode.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 12:34:05 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Thr Apr 20 11:46:00 2023
-// Update Count     : 1393
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Jun 17 14:41:48 2023
+// Update Count     : 1405
 //
 
@@ -459 +459 @@
         std::vector<ast::ptr<ast::Expr>> exprs;
         buildList( expr, exprs );
-        newnode->attributes.push_back(
-                new ast::Attribute( *name, std::move( exprs ) ) );
+        newnode->attributes.push_back( new ast::Attribute( *name, std::move( exprs ) ) );
         delete name;
         return newnode;
@@ -633 +632 @@
                                         dst->basictype = src->basictype;
                                 } else if ( src->basictype != DeclarationNode::NoBasicType )
-                                        SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::basicTypeNames[ src->basictype ] + " in type: " );
+                                        SemanticError( yylloc, string( "multiple declaration types \"" ) + DeclarationNode::basicTypeNames[ dst->basictype ] +
+                                                                   "\" and \"" + DeclarationNode::basicTypeNames[ src->basictype ] + "\"." );
 
                                 if ( dst->complextype == DeclarationNode::NoComplexType ) {
                                         dst->complextype = src->complextype;
                                 } else if ( src->complextype != DeclarationNode::NoComplexType )
-                                        SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::complexTypeNames[ src->complextype ] + " in type: " );
+                                        SemanticError( yylloc, string( "multiple declaration types \"" ) + DeclarationNode::complexTypeNames[ src->complextype ] +
+                                                                   "\" and \"" + DeclarationNode::complexTypeNames[ src->complextype ] + "\"." );
 
                                 if ( dst->signedness == DeclarationNode::NoSignedness ) {
                                         dst->signedness = src->signedness;
                                 } else if ( src->signedness != DeclarationNode::NoSignedness )
-                                        SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::signednessNames[ src->signedness ] + " in type: " );
+                                        SemanticError( yylloc, string( "conflicting type specifier \"" ) + DeclarationNode::signednessNames[ dst->signedness ] +
+                                                                   "\" and \"" + DeclarationNode::signednessNames[ src->signedness ] + "\"." );
 
                                 if ( dst->length == DeclarationNode::NoLength ) {
@@ -650 +652 @@
                                         dst->length = DeclarationNode::LongLong;
                                 } else if ( src->length != DeclarationNode::NoLength )
-                                        SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::lengthNames[ src->length ] + " in type: " );
+                                        SemanticError( yylloc, string( "conflicting type specifier \"" ) + DeclarationNode::lengthNames[ dst->length ] +
+                                                                   "\" and \"" + DeclarationNode::lengthNames[ src->length ] + "\"." );
                         } // if
                         break;
@@ -718 +721 @@
 
 DeclarationNode * DeclarationNode::addEnumBase( DeclarationNode * o ) {
-        if ( o && o -> type)  {
+        if ( o && o->type)  {
                 type->base= o->type;
-        }
+        } // if
         delete o;
         return this;
@@ -1003 +1006 @@
 }
 
-// If a typedef wraps an anonymous declaration, name the inner declaration
-// so it has a consistent name across translation units.
+// If a typedef wraps an anonymous declaration, name the inner declaration so it has a consistent name across
+// translation units.
 static void nameTypedefedDecl(
                 DeclarationNode * innerDecl,
@@ -1085 +1088 @@
 }
 
-void buildList( DeclarationNode * firstNode,
-                std::vector<ast::ptr<ast::Decl>> & outputList ) {
+void buildList( DeclarationNode * firstNode, std::vector<ast::ptr<ast::Decl>> & outputList ) {
         SemanticErrorException errors;
         std::back_insert_iterator<std::vector<ast::ptr<ast::Decl>>> out( outputList );

src/Parser/ExpressionNode.cc

@@ -601 +601 @@
 ast::Expr * build_cast( const CodeLocation & location,
                 DeclarationNode * decl_node,
-                ExpressionNode * expr_node ) {
+                ExpressionNode * expr_node,
+                ast::CastExpr::CastKind kind ) {
         ast::Type * targetType = maybeMoveBuildType( decl_node );
         if ( dynamic_cast<ast::VoidType *>( targetType ) ) {
@@ -607 +608 @@
                 return new ast::CastExpr( location,
                         maybeMoveBuild( expr_node ),
-                        ast::ExplicitCast );
+                        ast::ExplicitCast, kind );
         } else {
                 return new ast::CastExpr( location,
                         maybeMoveBuild( expr_node ),
                         targetType,
-                        ast::ExplicitCast );
+                        ast::ExplicitCast, kind );
         } // if
 } // build_cast

src/Parser/ExpressionNode.h

@@ -69 +69 @@
 ast::DimensionExpr * build_dimensionref( const CodeLocation &, const std::string * name );
 
-ast::Expr * build_cast( const CodeLocation &, DeclarationNode * decl_node, ExpressionNode * expr_node );
+ast::Expr * build_cast( const CodeLocation &, DeclarationNode * decl_node, ExpressionNode * expr_node, ast::CastExpr::CastKind kind = ast::CastExpr::Default );
 ast::Expr * build_keyword_cast( const CodeLocation &, ast::AggregateDecl::Aggregate target, ExpressionNode * expr_node );
 ast::Expr * build_virtual_cast( const CodeLocation &, DeclarationNode * decl_node, ExpressionNode * expr_node );

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jun  7 14:32:28 2023
-// Update Count     : 6341
+// Last Modified On : Sat Jun 17 18:53:24 2023
+// Update Count     : 6347
 //
 
@@ -931 +931 @@
                 { $$ = new ExpressionNode( new ast::VirtualCastExpr( yylloc, maybeMoveBuild( $5 ), maybeMoveBuildType( $3 ) ) ); }
         | '(' RETURN type_no_function ')' cast_expression       // CFA
-                { SemanticError( yylloc, "Return cast is currently unimplemented." ); $$ = nullptr; }
+                { $$ = new ExpressionNode( build_cast( yylloc, $3, $5, ast::CastExpr::Return ) ); }
         | '(' COERCE type_no_function ')' cast_expression       // CFA
                 { SemanticError( yylloc, "Coerce cast is currently unimplemented." ); $$ = nullptr; }
@@ -1040 +1040 @@
                 // FIX ME: computes $1 twice
         | logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand
-                { $$ = new ExpressionNode( build_cond( yylloc, $1, $1, $4 ) ); }
+                { $$ = new ExpressionNode( build_cond( yylloc, $1, $1->clone(), $4 ) ); }
         ;