Changeset 68e9ace

Timestamp:

May 2, 2018, 5:36:02 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, with_gc

Children:

161cdf1

Parents:

623c16a

Message:

Fixed semantic warning severity handling

Location:

src

Files:

• Common/SemanticError.cc (modified) (2 diffs)
• Common/SemanticError.h (modified) (2 diffs)
• main.cc (modified) (3 diffs)

src/Common/SemanticError.cc

@@ -16 +16 @@
 #include <cstdarg>
 #include <cstdio>                                                                               // for fileno, stderr
+#include <cstring>
 #include <unistd.h>                                                                             // for isatty
 #include <iostream>                                                                             // for basic_ostream, operator<<, ostream
 #include <list>                                                                                 // for list, _List_iterator
 #include <string>                                                                               // for string, operator<<, operator+, to_string
+#include <vector>
 
 #include "Common/utility.h"                                                             // for to_string, CodeLocation (ptr only)
 #include "SemanticError.h"
 
+//-----------------------------------------------------------------------------
+// Severity Handling
+std::vector<Severity> & get_severities() {
+        static std::vector<Severity> severities;
+        if(severities.empty()) {
+                severities.reserve((size_t)Warning::NUMBER_OF_WARNINGS);
+                for ( const auto w : WarningFormats ) {
+                        severities.push_back( w.default_severity );
+                } // for
+        }
+        return severities;
+}
+
+void SemanticWarning_SuppressAll() {
+        for( auto & s : get_severities() ) {
+                s = Severity::Suppress;
+        }
+}
+
+void SemanticWarning_EnableAll() {
+        for( auto & s : get_severities() ) {
+                s = Severity::Warn;
+        }
+}
+
+void SemanticWarning_WarningAsError() {
+        for( auto & s : get_severities() ) {
+                if(s == Severity::Warn) s = Severity::Error;
+        }
+}
+
+void SemanticWarning_Set(const char * const name, Severity s) {
+        size_t idx = 0;
+        for ( auto  & w : WarningFormats ) {
+                if ( std::strcmp( name, w.name ) == 0 ) {
+                        get_severities()[idx] = s;
+                        break;
+                }
+                idx++;
+        }
+}
+
+//-----------------------------------------------------------------------------
+// Semantic Error
 SemanticErrorException::SemanticErrorException( CodeLocation location, std::string error ) {
         append( location, error );
@@ -69 +115 @@
 
 void SemanticWarningImpl( CodeLocation location, Warning warning, const char * const fmt, ... ) {
-        Severity severity = WarningFormats[(int)warning].severity;
+        Severity severity = get_severities()[(int)warning];
         switch(severity) {
         case Severity::Suppress :

src/Common/SemanticError.h

@@ -46 +46 @@
         const char * const name;
         const char * const message;
-        mutable Severity severity;
+        const Severity default_severity;
 };
 
 constexpr WarningData WarningFormats[] = {
-        {"self-assign"         , "self assignment of expression: %s"           , Severity::Warn},
-        {"reference-conversion", "rvalue to reference conversion of rvalue: %s", Severity::Warn},
+        {"self-assign"            , "self assignment of expression: %s"            , Severity::Warn},
+        {"reference-conversion"   , "rvalue to reference conversion of rvalue: %s" , Severity::Warn},
         {"qualifiers-zero_t-one_t", "questionable use of type qualifier %s with %s", Severity::Warn},
 };
@@ -71 +71 @@
 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);
 
 //-----------------------------------------------------------------------------

src/main.cc

@@ -508 +508 @@
                         break;
                   case 'w':
-                        for ( auto & w : WarningFormats ) {
-                                w.severity = Severity::Suppress;
-                        } // for
+                        SemanticWarning_SuppressAll();
                         break;
                   case 'W':
                         if ( strcmp( optarg, "all" ) == 0 ) {
-                                for ( auto & w : WarningFormats ) {
-                                        if ( w.severity == Severity::Suppress ) w.severity = Severity::Warn;
-                                } // for
+                                SemanticWarning_EnableAll();
                         } else if ( strcmp( optarg, "error" ) == 0 ) {
                                 Werror = true;
@@ -528 +524 @@
                                         s = Severity::Warn;
                                 } // if
-                                for ( auto  & w : WarningFormats ) {
-                                        if ( strcmp( warning, w.name ) == 0 ) { // replace the argument for cfa-cpp
-                                                w.severity = s;
-                                                break;
-                                        } // if
-                                } // for
+                                SemanticWarning_Set( warning, s );
                         } // if
                         break;
@@ -566 +557 @@
 
         if ( Werror ) {
-                for ( auto & w : WarningFormats ) {
-                        if ( w.severity == Severity::Warn ) w.severity = Severity::Error;
-                } // for
+                SemanticWarning_WarningAsError();
         } // if
         // for ( const auto w : WarningFormats ) {