source: src/Common/SemanticError.cc

Last change on this file was ddcedfe, checked in by Thierry Delisle <tdelisle@…>, 14 months ago

Errors are now sorted by code-location/description

  • Property mode set to 100644
File size: 5.2 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// SemanticError.cc --
8//
9// Author           : Thierry Delisle
10// Created On       : Mon May 18 07:44:20 2015
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Thu Jun  7 08:05:26 2018
13// Update Count     : 10
14//
15
16#include <cstdarg>
17#include <cstdio>                                                                               // for fileno, stderr
18#include <cstring>
19#include <unistd.h>                                                                             // for isatty
20#include <iostream>                                                                             // for basic_ostream, operator<<, ostream
21#include <list>                                                                                 // for list, _List_iterator
22#include <string>                                                                               // for string, operator<<, operator+, to_string
23#include <vector>
24
25#include "Common/utility.h"                                                             // for to_string, CodeLocation (ptr only)
26#include "SemanticError.h"
27
28//-----------------------------------------------------------------------------
29// Severity Handling
30std::vector<Severity> & get_severities() {
31        static std::vector<Severity> severities;
32        if(severities.empty()) {
33                severities.reserve((size_t)Warning::NUMBER_OF_WARNINGS);
34                for ( const auto w : WarningFormats ) {
35                        severities.push_back( w.default_severity );
36                } // for
37        }
38        return severities;
39}
40
41void SemanticWarning_SuppressAll() {
42        for( auto & s : get_severities() ) {
43                s = Severity::Suppress;
44        }
45}
46
47void SemanticWarning_EnableAll() {
48        for( auto & s : get_severities() ) {
49                s = Severity::Warn;
50        }
51}
52
53void SemanticWarning_WarningAsError() {
54        for( auto & s : get_severities() ) {
55                if(s == Severity::Warn) s = Severity::Error;
56        }
57}
58
59void SemanticWarning_Set(const char * const name, Severity s) {
60        size_t idx = 0;
61        for ( const auto & w : WarningFormats ) {
62                if ( std::strcmp( name, w.name ) == 0 ) {
63                        get_severities()[idx] = s;
64                        break;
65                }
66                idx++;
67        }
68}
69
70//-----------------------------------------------------------------------------
71// Semantic Error
72bool SemanticErrorThrow = false;
73
74SemanticErrorException::SemanticErrorException( CodeLocation location, std::string error ) {
75        append( location, error );
76}
77
78void SemanticErrorException::append( SemanticErrorException &other ) {
79        errors.splice( errors.end(), other.errors );
80}
81
82void SemanticErrorException::append( CodeLocation location, const std::string & msg ) {
83        errors.emplace_back( location, msg );
84}
85
86bool SemanticErrorException::isEmpty() const {
87        return errors.empty();
88}
89
90void SemanticErrorException::print() {
91        using std::to_string;
92
93        errors.sort([](const error & lhs, const error & rhs) -> bool {
94                if(lhs.location.startsBefore(rhs.location)) return true;
95                if(rhs.location.startsBefore(lhs.location)) return false;
96
97                return lhs.description < rhs.description;
98        });
99
100        for( auto err : errors ) {
101                std::cerr << ErrorHelpers::bold() << err.location << ErrorHelpers::error_str() << ErrorHelpers::reset_font() << err.description << std::endl;
102        }
103}
104
105void SemanticError( CodeLocation location, std::string error ) {
106        SemanticErrorThrow = true;
107        throw SemanticErrorException( location, error );
108}
109
110namespace {
111        // convert format string and arguments into a single string
112        std::string fmtToString(const char * fmt, va_list ap) {
113                int size = 128;
114                while ( true ) {
115                        char buf[size];
116                        va_list args;
117                        va_copy( args, ap );
118                        int n = vsnprintf(&buf[0], size, fmt, args);
119                        va_end( args );
120                        if ( n < size && n >= 0 ) return buf;
121                        size *= 2;
122                }
123                assert( false );
124        }
125}
126
127void SemanticWarningImpl( CodeLocation location, Warning warning, const char * const fmt, ... ) {
128        Severity severity = get_severities()[(int)warning];
129        switch(severity) {
130        case Severity::Suppress :
131                break;
132        case Severity::Warn :
133                {
134                        va_list args;
135                        va_start(args, fmt);
136                        std::string msg = fmtToString( fmt, args );
137                        va_end(args);
138                        std::cerr << ErrorHelpers::bold() << location << ErrorHelpers::warning_str() << ErrorHelpers::reset_font() << msg << std::endl;
139                }
140                break;
141        case Severity::Error :
142                {
143                        va_list args;
144                        va_start(args, fmt);
145                        std::string msg = fmtToString( fmt, args );
146                        va_end(args);
147                        SemanticError(location, msg);
148                }
149                break;
150        case Severity::Critical :
151                assertf(false, "Critical errors not implemented yet");
152                break;
153        }
154}
155
156//-----------------------------------------------------------------------------
157// Helpers
158namespace ErrorHelpers {
159        Colors colors = Colors::Auto;
160
161        static inline bool with_colors() {
162                return colors == Colors::Auto ? isatty( STDERR_FILENO ) : bool(colors);
163        }
164
165        const std::string & error_str() {
166                static std::string str = with_colors() ? "\e[31merror:\e[39m " : "error: ";
167                return str;
168        }
169
170        const std::string & warning_str() {
171                static std::string str = with_colors() ? "\e[95mwarning:\e[39m " : "warning: ";
172                return str;
173        }
174
175        const std::string & bold_ttycode() {
176                static std::string str = with_colors() ? "\e[1m" : "";
177                return str;
178        }
179
180        const std::string & reset_font_ttycode() {
181                static std::string str = with_colors() ? "\e[0m" : "";
182                return str;
183        }
184
185        std::string make_bold( const std::string & str ) {
186                return bold_ttycode() + str + reset_font_ttycode();
187        }
188
189        std::ostream & operator<<(std::ostream & os, bold) {
190                os << bold_ttycode();
191                return os;
192        }
193
194        std::ostream & operator<<(std::ostream & os, reset_font) {
195                os << reset_font_ttycode();
196                return os;
197        }
198}
199
200// Local Variables: //
201// tab-width: 4 //
202// mode: c++ //
203// compile-command: "make install" //
204// End: //
Note: See TracBrowser for help on using the repository browser.