Changes in / [21ad568:142930b]

Location:

src/Common

Files:

• ErrorObjects.h (modified) (1 diff)
• SemanticError.cc (modified) (10 diffs)
• SemanticError.h (modified) (4 diffs)

src/Common/ErrorObjects.h

@@ -46 +46 @@
         std::list< error > errors;
 };
+
+void SemanticWarningImpl( CodeLocation location, std::string error );
+
+template< typename T >
+static inline void SemanticWarningImpl( const T * obj, const std::string & error ) {
+        SemanticWarning( obj->location, toString( error, obj ) );
+}
+
+template< typename T >
+static inline void SemanticWarningImpl( CodeLocation location, const T * obj, const std::string & error ) {
+        SemanticWarningImpl( location, toString( error, obj ) );
+}

src/Common/SemanticError.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Dec 14 13:45:28 2023
-// Update Count     : 34
+// Last Modified On : Mon Dec 11 15:59:09 2023
+// Update Count     : 14
 //
 
@@ -23 +23 @@
 #include <vector>
 
-using namespace std;
-
 #include "Common/utility.h"                                                             // for to_string, CodeLocation (ptr only)
 #include "SemanticError.h"
@@ -30 +28 @@
 //-----------------------------------------------------------------------------
 // Severity Handling
-vector<Severity> & get_severities() {
-        static vector<Severity> severities;
+std::vector<Severity> & get_severities() {
+        static std::vector<Severity> severities;
         if(severities.empty()) {
                 severities.reserve((size_t)Warning::NUMBER_OF_WARNINGS);
@@ -62 +60 @@
         size_t idx = 0;
         for ( const auto & w : WarningFormats ) {
-                if ( strcmp( name, w.name ) == 0 ) {
+                if ( std::strcmp( name, w.name ) == 0 ) {
                         get_severities()[idx] = s;
                         break;
@@ -75 +73 @@
 bool SemanticErrorThrow = false;
 
-SemanticErrorException::SemanticErrorException( CodeLocation location, string error ) {
+SemanticErrorException::SemanticErrorException( CodeLocation location, std::string error ) {
         append( location, error );
 }
@@ -83 +81 @@
 }
 
-void SemanticErrorException::append( CodeLocation location, const string & msg ) {
+void SemanticErrorException::append( CodeLocation location, const std::string & msg ) {
         errors.emplace_back( location, msg );
 }
@@ -92 +90 @@
 
 void SemanticErrorException::print() {
-//      using to_string;
+        using std::to_string;
 
         errors.sort([](const error & lhs, const error & rhs) -> bool {
@@ -102 +100 @@
 
         for( auto err : errors ) {
-                cerr << ErrorHelpers::bold() << err.location << ErrorHelpers::error_str() << ErrorHelpers::reset_font() << err.description << endl;
+                std::cerr << ErrorHelpers::bold() << err.location << ErrorHelpers::error_str() << ErrorHelpers::reset_font() << err.description << std::endl;
         }
 }
@@ -117 +115 @@
 }
 
-void SemanticWarning( CodeLocation location, Warning warning, ... ) {
+void SemanticError( CodeLocation location, std::string error ) {
+        SemanticErrorThrow = true;
+        throw SemanticErrorException( location, error );
+}
+
+namespace {
+        // convert format string and arguments into a single string
+        std::string fmtToString(const char * fmt, va_list ap) {
+                int size = 128;
+                while ( true ) {
+                        char buf[size];
+                        va_list args;
+                        va_copy( args, ap );
+                        int n = vsnprintf(&buf[0], size, fmt, args);
+                        va_end( args );
+                        if ( n < size && n >= 0 ) return buf;
+                        size *= 2;
+                }
+                assert( false );
+        }
+}
+
+void SemanticWarningImpl( CodeLocation location, Warning warning, const char * const fmt, ... ) {
         Severity severity = get_severities()[(int)warning];
-
-        switch ( severity ) {
+        switch(severity) {
         case Severity::Suppress :
                 break;
         case Severity::Warn :
+                {
+                        va_list args;
+                        va_start(args, fmt);
+                        std::string msg = fmtToString( fmt, args );
+                        va_end(args);
+                        std::cerr << ErrorHelpers::bold() << location << ErrorHelpers::warning_str() << ErrorHelpers::reset_font() << msg << std::endl;
+                }
+                break;
         case Severity::Error :
                 {
-                        char msg[2048];                                                         // worst-case error-message buffer
                         va_list args;
-                        va_start( args, warning );
-                        vsnprintf( msg, sizeof(msg), WarningFormats[(int)warning].message, args ); // always null terminated, but may be truncated
-                        va_end( args );
-
-                        if ( severity == Severity::Warn ) {
-                                cerr << ErrorHelpers::bold() << location << ErrorHelpers::warning_str() << ErrorHelpers::reset_font() << msg << endl;
-                        } else {
-                                SemanticError( location, string( msg ) );
-                        }
+                        va_start(args, fmt);
+                        std::string msg = fmtToString( fmt, args );
+                        va_end(args);
+                        SemanticError(location, msg);
                 }
                 break;
@@ -154 +175 @@
         }
 
-        const string & error_str() {
-                static string str = with_colors() ? "\e[31merror:\e[39m " : "error: ";
-                return str;
-        }
-
-        const string & warning_str() {
-                static string str = with_colors() ? "\e[95mwarning:\e[39m " : "warning: ";
-                return str;
-        }
-
-        const string & bold_ttycode() {
-                static string str = with_colors() ? "\e[1m" : "";
-                return str;
-        }
-
-        const string & reset_font_ttycode() {
-                static string str = with_colors() ? "\e[0m" : "";
-                return str;
-        }
-
-        string make_bold( const string & str ) {
+        const std::string & error_str() {
+                static std::string str = with_colors() ? "\e[31merror:\e[39m " : "error: ";
+                return str;
+        }
+
+        const std::string & warning_str() {
+                static std::string str = with_colors() ? "\e[95mwarning:\e[39m " : "warning: ";
+                return str;
+        }
+
+        const std::string & bold_ttycode() {
+                static std::string str = with_colors() ? "\e[1m" : "";
+                return str;
+        }
+
+        const std::string & reset_font_ttycode() {
+                static std::string str = with_colors() ? "\e[0m" : "";
+                return str;
+        }
+
+        std::string make_bold( const std::string & str ) {
                 return bold_ttycode() + str + reset_font_ttycode();
         }
 
-        ostream & operator<<(ostream & os, bold) {
+        std::ostream & operator<<(std::ostream & os, bold) {
                 os << bold_ttycode();
                 return os;
         }
 
-        ostream & operator<<(ostream & os, reset_font) {
+        std::ostream & operator<<(std::ostream & os, reset_font) {
                 os << reset_font_ttycode();
                 return os;

src/Common/SemanticError.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Dec 14 13:48:07 2023
-// Update Count     : 72
+// Last Modified On : Mon Dec 11 21:54:22 2023
+// Update Count     : 54
 //
 
@@ -28 +28 @@
 __attribute__((noreturn, format(printf, 2, 3))) void SemanticError( CodeLocation location, const char fmt[], ... );
 
-__attribute__((noreturn)) static inline void SemanticError( CodeLocation location, std::string error ) {
-        SemanticErrorThrow = true;
-        throw SemanticErrorException( location, error );
-}
+__attribute__((noreturn)) void SemanticError( CodeLocation location, std::string error );
 
 __attribute__((noreturn)) static inline void SemanticError( const ast::ParseNode * obj, const std::string & error ) {
@@ -79 +76 @@
         CppCopy,
         DeprecTraitSyntax,
-        NUMBER_OF_WARNINGS, // MUST be last warning
+        NUMBER_OF_WARNINGS, // MUST be the last warning
 };
 
@@ -87 +84 @@
 );
 
-void SemanticWarning( CodeLocation loc, Warning warn, ... );
+#define SemanticWarning(loc, id, ...) SemanticWarningImpl(loc, id, WarningFormats[(int)id].message, ##__VA_ARGS__)
 
-void SemanticWarning_SuppressAll();
-void SemanticWarning_EnableAll();
+void SemanticWarningImpl (CodeLocation loc, Warning warn, const char * const fmt, ...) __attribute__((format(printf, 3, 4)));
+
+void SemanticWarning_SuppressAll   ();
+void SemanticWarning_EnableAll     ();
 void SemanticWarning_WarningAsError();
-void SemanticWarning_Set(const char * const name, Severity s);
+void SemanticWarning_Set           (const char * const name, Severity s);
 
 // SKULLDUGGERY: cfa.cc is built before SemanticError.cc but needs this routine.