Changes in src/Parser/DeclarationNode.cc [b38f6da:45e753c]

File:

• src/Parser/DeclarationNode.cc (modified) (7 diffs)

src/Parser/DeclarationNode.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 12:34:05 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jun 17 14:41:48 2023
-// Update Count     : 1405
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Apr 20 11:46:00 2023
+// Update Count     : 1393
 //
 
@@ -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;
@@ -632 +633 @@
                                         dst->basictype = src->basictype;
                                 } else if ( src->basictype != DeclarationNode::NoBasicType )
-                                        SemanticError( yylloc, string( "multiple declaration types \"" ) + DeclarationNode::basicTypeNames[ dst->basictype ] +
-                                                                   "\" and \"" + DeclarationNode::basicTypeNames[ src->basictype ] + "\"." );
+                                        SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::basicTypeNames[ src->basictype ] + " in type: " );
 
                                 if ( dst->complextype == DeclarationNode::NoComplexType ) {
                                         dst->complextype = src->complextype;
                                 } else if ( src->complextype != DeclarationNode::NoComplexType )
-                                        SemanticError( yylloc, string( "multiple declaration types \"" ) + DeclarationNode::complexTypeNames[ src->complextype ] +
-                                                                   "\" and \"" + DeclarationNode::complexTypeNames[ src->complextype ] + "\"." );
+                                        SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::complexTypeNames[ src->complextype ] + " in type: " );
 
                                 if ( dst->signedness == DeclarationNode::NoSignedness ) {
                                         dst->signedness = src->signedness;
                                 } else if ( src->signedness != DeclarationNode::NoSignedness )
-                                        SemanticError( yylloc, string( "conflicting type specifier \"" ) + DeclarationNode::signednessNames[ dst->signedness ] +
-                                                                   "\" and \"" + DeclarationNode::signednessNames[ src->signedness ] + "\"." );
+                                        SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::signednessNames[ src->signedness ] + " in type: " );
 
                                 if ( dst->length == DeclarationNode::NoLength ) {
@@ -652 +650 @@
                                         dst->length = DeclarationNode::LongLong;
                                 } else if ( src->length != DeclarationNode::NoLength )
-                                        SemanticError( yylloc, string( "conflicting type specifier \"" ) + DeclarationNode::lengthNames[ dst->length ] +
-                                                                   "\" and \"" + DeclarationNode::lengthNames[ src->length ] + "\"." );
+                                        SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::lengthNames[ src->length ] + " in type: " );
                         } // if
                         break;
@@ -721 +718 @@
 
 DeclarationNode * DeclarationNode::addEnumBase( DeclarationNode * o ) {
-        if ( o && o->type)  {
+        if ( o && o -> type)  {
                 type->base= o->type;
-        } // if
+        }
         delete o;
         return this;
@@ -1006 +1003 @@
 }
 
-// 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,
@@ -1088 +1085 @@
 }
 
-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 );