Changeset ca9d65e for src/Parser

Timestamp:

Dec 14, 2023, 9:05:55 PM (22 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

19a2890

Parents:

21ad568

Message:

second attempt at simplifying SemanticError messages

Location:

src/Parser

Files:

• DeclarationNode.cc (modified) (3 diffs)
• ExpressionNode.cc (modified) (8 diffs)
• TypeData.cc (modified) (2 diffs)

src/Parser/DeclarationNode.cc

@@ -10 +10 @@
 // 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 On : Thu Dec 14 19:05:17 2023
+// Update Count     : 1407
 //
 
@@ -632 +632 @@
                                         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, "multiple declaration types \"%s\" and \"%s\".",
+                                                                   DeclarationNode::basicTypeNames[ dst->basictype ],
+                                                                   DeclarationNode::basicTypeNames[ src->basictype ] );
                                 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, "multiple declaration types \"%s\" and \"%s\".",
+                                                                   DeclarationNode::complexTypeNames[ src->complextype ],
+                                                                   DeclarationNode::complexTypeNames[ src->complextype ] );
                                 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, "conflicting type specifier \"%s\" and \"%s\".",
+                                                                   DeclarationNode::signednessNames[ dst->signedness ],
+                                                                   DeclarationNode::signednessNames[ src->signedness ] );
                                 if ( dst->length == DeclarationNode::NoLength ) {
                                         dst->length = src->length;
@@ -652 +652 @@
                                         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, "conflicting type specifier \"%s\" and \"%s\".",
+                                                                   DeclarationNode::lengthNames[ dst->length ],
+                                                                   DeclarationNode::lengthNames[ src->length ] );
                         } // if
                         break;

src/Parser/ExpressionNode.cc

@@ -9 +9 @@
 // Author           : Peter A. Buhr
 // Created On       : Sat May 16 13:17:07 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Tue Apr  4 11:07:00 2023
-// Update Count     : 1083
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Dec 14 18:57:07 2023
+// Update Count     : 1087
 //
 
@@ -193 +193 @@
 
 #if ! defined(__SIZEOF_INT128__)
-        if ( type == 5 ) SemanticError( yylloc, "int128 constant is not supported on this target " + str );
+        if ( type == 5 ) SemanticError( yylloc, "int128 constant is not supported on this target \"%s\"", str.c_str() );
 #endif // ! __SIZEOF_INT128__
 
@@ -204 +204 @@
                         } else {                                                                        // hex int128 constant
                                 unsigned int len = str.length();
-                                if ( len > (2 + 16 + 16) ) SemanticError( yylloc, "128-bit hexadecimal constant to large " + str );
+                                if ( len > (2 + 16 + 16) ) SemanticError( yylloc, "128-bit hexadecimal constant to large \"%s\"", str.c_str() );
                                 // hex digits < 2^64
                                 if ( len > (2 + 16) ) {
@@ -219 +219 @@
                         unsigned int len = str.length();
                         if ( type == 5 && len > 2 + 64 ) {
-                                if ( len > 2 + 64 + 64 ) SemanticError( yylloc, "128-bit binary constant to large " + str );
+                                if ( len > 2 + 64 + 64 ) SemanticError( yylloc, "128-bit binary constant to large \"%s\".", str.c_str() );
                                 str2 = "0b" + str.substr( len - 64 );
                                 str = str.substr( 0, len - 64 );
@@ -233 +233 @@
                         } else {                                                                        // octal int128 constant
                                 unsigned int len = str.length();
-                                if ( len > 1 + 43 || (len == 1 + 43 && str[0] > '3') ) SemanticError( yylloc, "128-bit octal constant to large " + str );
+                                if ( len > 1 + 43 || (len == 1 + 43 && str[0] > '3') ) SemanticError( yylloc, "128-bit octal constant to large \"%s\"", str.c_str() );
                                 char buf[32];
                                 if ( len <= 1 + 21 ) {                                  // value < 21 octal digitis
@@ -266 +266 @@
                         unsigned int len = str.length();
                         if ( str.length() == 39 && str > (Unsigned ? "340282366920938463463374607431768211455" : "170141183460469231731687303715884105727") )
-                                SemanticError( yylloc, "128-bit decimal constant to large " + str );
+                                SemanticError( yylloc, "128-bit decimal constant to large \"%s\".", str.c_str() );
                         char buf[32];
                         if ( len <= 19 ) {                                                      // value < 19 decimal digitis
@@ -502 +502 @@
 ast::Expr * build_field_name_FLOATING_FRACTIONconstant(
                 const CodeLocation & location, const string & str ) {
-        if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) SemanticError( yylloc, "invalid tuple index " + str );
+        if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) SemanticError( yylloc, "invalid tuple index \"%s\".", str.c_str() );
         ast::Expr * ret = build_constantInteger( location,
                 *new string( str.substr(1) ) );
@@ -511 +511 @@
 ast::Expr * build_field_name_FLOATING_DECIMALconstant(
                 const CodeLocation & location, const string & str ) {
-        if ( str[str.size() - 1] != '.' ) SemanticError( yylloc, "invalid tuple index " + str );
+        if ( str[str.size() - 1] != '.' ) SemanticError( yylloc, "invalid tuple index \"%s\".", str.c_str() );
         ast::Expr * ret = build_constantInteger(
                 location, *new string( str.substr( 0, str.size()-1 ) ) );

src/Parser/TypeData.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Nov 26 15:51:05 2023
-// Update Count     : 681
+// Last Modified On : Thu Dec 14 18:59:12 2023
+// Update Count     : 684
 //
 
@@ -1496 +1496 @@
                                 // type set => parameter name already transformed by a declaration names so there is a duplicate
                                 // declaration name attempting a second transformation
-                                if ( param->type ) SemanticError( param->location, string( "duplicate declaration name " ) + *param->name );
+                                if ( param->type ) SemanticError( param->location, "duplicate declaration name \"%s\".", param->name->c_str() );
                                 // declaration type reset => declaration already transformed by a parameter name so there is a duplicate
                                 // parameter name attempting a second transformation
-                                if ( ! decl->type ) SemanticError( param->location, string( "duplicate parameter name " ) + *param->name );
+                                if ( ! decl->type ) SemanticError( param->location, "duplicate parameter name \"%s\".", param->name->c_str() );
                                 param->type = decl->type;                               // set copy declaration type to parameter type
                                 decl->type = nullptr;                                   // reset declaration type