diagnostic.h

Go to the documentation of this file.

#ifndef DIAGNOSTIC_H
#define DIAGNOSTIC_H
#pragma once
/***************************************************************************
 *   Copyright (C) 2007-2013 Mike Kinghan, imk@burroingroingjoing.com      *
 *   All rights reserved.                                                  *
 *                                                                         *
 *   Contributed originally by Mike Kinghan, imk@burroingroingjoing.com    *
 *                                                                         *
 *   Redistribution and use in source and binary forms, with or without    *
 *   modification, are permitted provided that the following conditions    *
 *   are met:                                                              *
 *                                                                         *
 *   Redistributions of source code must retain the above copyright        *
 *   notice, this list of conditions and the following disclaimer.         *
 *                                                                         *
 *   Redistributions in binary form must reproduce the above copyright     *
 *   notice, this list of conditions and the following disclaimer in the   *
 *   documentation and/or other materials provided with the distribution.  *
 *                                                                         *
 *   Neither the name of Mike Kinghan nor the names of its contributors    *
 *   may be used to endorse or promote products derived from this software *
 *   without specific prior written permission.                            *
 *                                                                         *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS   *
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT     *
 *   LIMITED TO, THE IMPLIED WARRANTIES OF  MERCHANTABILITY AND FITNESS    *
 *   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE        *
 *   COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,   *
 *   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,  *
 *   BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS *
 *   OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED    *
 *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,*
 *   OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF *
 *   THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH  *
 *   DAMAGE.                                                               *
 *                                                                         *
 **************************************************************************/

#include "prohibit.h"
#include "cloner.h"
#include <sstream>
#include <list>
#include <memory>

enum struct severity {
    none = 0,
    progress = 1,
    info = 2,
    warning = 4,
    error = 8,
    abend = 16,
    summary = 32,
    summary_progress = summary | progress,
    summary_info = summary | info,
    summary_warning = summary | warning
};

struct emit {};

struct defer {};

struct diagnostic_base : private no_assign {

        using ptr = std::shared_ptr<diagnostic_base>;

        diagnostic_base(std::string const & severity_name,
                        severity level, unsigned id,
                        bool in_code_only = false);

        diagnostic_base(diagnostic_base const & src)
                : _gagged(src._gagged),_text(src._text.str()) {}


        virtual ~diagnostic_base() = default;

        void queue() const {
                _queue_.push_back(ptr(clone()));
        }

        virtual severity level() const {
                return severity::none;
        }

        virtual unsigned id() const {
                return 0;
        }

        unsigned encode() const {
                return code(level(),id());
        }

        explicit operator unsigned () const {
                return encode();
        }

        bool gagged() const {
                return _gagged;
        }

        std::string text() const {
                return _text.str();
        }

        explicit operator std::string () const {
                return text();
        }

        template<typename T>
        diagnostic_base & operator<<(T const & obj) {
                if (!_gagged) {
                        _text << obj;
                }
                return *this;
        }

        diagnostic_base & operator<<(defer) {
                if (!_gagged) {
                        queue();
                }
                return *this;
        }

        diagnostic_base & operator<<(emit) {
                if (!_gagged) {
                        despatch();
                }
                return *this;
        }

        static size_t deferred() {
                return _queue_.size();
        }

        static size_t discard(unsigned reason) {
                return volley(reason,&diagnostic_base::encode);
        }

        static size_t discard(severity level) {
                return volley(level,&diagnostic_base::level);
        }

        static void discard_all() {
                _queue_.resize(0);
        }

        static size_t flush(unsigned reason) {
                return volley(
                                        reason,
                                        &diagnostic_base::encode,
                                        &diagnostic_base::despatch);
        }

        static size_t flush(severity level) {
                return volley(
                                        level,
                                        &diagnostic_base::level,
                                        &diagnostic_base::despatch);
        }

        static void flush_all();


        static void epilogue();

        static int exitcode();

protected:

        virtual void count() const {}

        virtual diagnostic_base * clone() const {
            return new diagnostic_base(*this);
        }

        void despatch() const throw (unsigned);

        bool _gagged;

        std::stringstream _text;

        static unsigned code(severity level, unsigned id) {
                return (int(level) << 8) | id;
        }

        static std::list<ptr> _queue_;

        static unsigned _infos_;
        static unsigned _warnings_;
        static unsigned _errors_;
        static unsigned _abends_;
        static unsigned _error_directives_generated_;
        static unsigned _error_directives_operative_;

private:

        template<class T>
        static size_t
        volley(
                T match,
                T (diagnostic_base::*selector)() const,
                void (diagnostic_base::*action)() const = nullptr)
        {
                if (match == T(0)) {
                        return 0;
                }
                size_t shots = 0;
                std::list<ptr>::iterator qit(_queue_.begin());
                while ( qit != _queue_.end()) {
                        if ((qit->get()->*selector)() == match) {
                                if (action) {
                                        (qit->get()->*action)();
                                }
                                qit = _queue_.erase(qit);
                                ++shots;
                        } else {
                                ++qit;
                        }
                }
                return shots;
        }

};

template<severity Level, unsigned Id>
struct diagnostic : cloner<diagnostic_base,diagnostic<Level,Id>>
{

    using base = cloner<diagnostic_base,diagnostic<Level,Id>>;

        static const severity _severity_ = Level;
        static const unsigned _id_ = Id;

        explicit diagnostic(std::string const & severity_name)
                : base(severity_name,Level,Id) {}

        severity level() const {
                return Level;
        }

        unsigned id() const {
                return Id;
        }

        static unsigned code() {
                return diagnostic_base::code(Level,Id);
        }

        static size_t discard() {
                return diagnostic_base::discard(code());
        }

        static size_t flush() {
                return diagnostic_base::flush(code());
        }
};

template<unsigned Id>
struct progress_msg : cloner<diagnostic<severity::progress,Id>,progress_msg<Id>>
{
    using base = cloner<diagnostic<severity::progress,Id>,progress_msg<Id>>;

        progress_msg()
                : base("progress") {}
};

template<unsigned Id>
struct info_msg : cloner<diagnostic<severity::info,Id>,info_msg<Id>>
{
    using base = cloner<diagnostic<severity::info,Id>,info_msg<Id>>;

        info_msg()
                : base("info") {}

private:

        void count() const override {
                ++base::_infos_;
        };

};

template<unsigned Id>
struct warning_msg : cloner<diagnostic<severity::warning,Id>,warning_msg<Id>>
{
    using base = cloner<diagnostic<severity::warning,Id>,warning_msg<Id>>;

        warning_msg()
                : base("warning") {}

private:
        virtual void count() const override {
                ++base::_warnings_;
        };

};

template<unsigned Id>
struct error_msg : cloner<diagnostic<severity::error,Id>,error_msg<Id>>
{
    using base = cloner<diagnostic<severity::error,Id>,error_msg<Id>>;

        error_msg()
                : base("error") {}

private:
        void count() const override {
                ++base::_errors_;
        };

};

template<unsigned Id>
struct abend_msg : cloner<diagnostic<severity::abend,Id>,abend_msg<Id>>
{
    using base = cloner<diagnostic<severity::abend,Id>,abend_msg<Id>>;

        abend_msg()
                : base("abend") {}

private:
        void count() const override {
                ++base::_abends_;
        };

};

template<unsigned Id>
struct progress_summary_msg :
                diagnostic<severity::summary_progress,Id> {
        progress_summary_msg()
                : diagnostic<severity::summary_progress,Id>("progress") {}
};

template<unsigned Id>
struct info_summary_msg : diagnostic<severity::summary_info,Id> {
        info_summary_msg()
                : diagnostic<severity::summary_info,Id>("info") {}
};

template<unsigned Id>
struct warning_summary_msg :
                diagnostic<severity::summary_warning,Id> {
        warning_summary_msg()
                : diagnostic<severity::summary_warning,Id>("warning") {}
};

using progress_processing_file = progress_msg<1> ;
using progress_building_tree = progress_msg<2>;
using  progress_added_file = progress_msg<3>;
using  progress_file_tracker = progress_msg<4>;
using progress_got_options = progress_msg<5>;
using  info_duplicate_mask = info_msg<1>;
using  info_symlink = info_msg<2>;
using  info_retrospective_redefinition = info_msg<3>;

using  warning_duplicate_args = warning_msg<1>;

using  warning_deleted_contradiction = warning_msg<2>;
using  warning_commented_contradiction = warning_msg<3>;
using warning_errored_contradiction = warning_msg<4>;
using  warning_differing_redef = warning_msg<5>;

using  warning_undefing_defined = warning_msg<6>;

struct warning_unconditional_error_input : warning_msg<7> {
private:
        void count() const override {
                ++_warnings_;
                ++_error_directives_operative_;
        }
};
struct warning_error_generated : warning_msg<8> {
private:
        void count() const override {
                ++_warnings_;
                ++_error_directives_generated_;
        }
};
struct warning_unconditional_error_output : warning_msg<9> {
private:
        void count() const override {
                ++_warnings_;
                ++_error_directives_operative_;
        }
};
using  warning_garbage_after_directive = warning_msg<10>;
using  warning_missing_eof_newline = warning_msg<11>;
using  warning_infinite_regress = warning_msg<12>;
using  warning_verbose_only = warning_msg<13>;
using warning_zero_divide =  warning_msg<14>;
using  warning_dir_ignored = warning_msg<15>;
using  warning_unknown_directive = warning_msg<16>;
using  warning_invalid_include = warning_msg<17>;
using warning_int_overflow = warning_msg<18>;
using  warning_missing_terminator = warning_msg<19>;
using warning_negative_shift = warning_msg<20>;
using warning_forced_unsigned = warning_msg<21>;
using warning_sign_changed = warning_msg<22>;
using warning_shift_overflow = warning_msg<23>;
using warning_char_constant_too_long = warning_msg<24>;
using  warning_mulitbyte_char_constant = warning_msg<25>;
using warning_variadic_macros_unsupported = warning_msg<26>;
using warning_transient_symbol_added = warning_msg<27>;
using warning_no_syms = warning_msg<28>;
using warning_broken_symlink = warning_msg<29>;
using warning_no_transients_used = warning_msg<30>;
using warning_calling_unconfigured = warning_msg<31>;
using warning_no_argument = warning_msg<32>;
using warning_not_a_line_number = warning_msg<33>;
using warning_inconsistent_calls = warning_msg<34>;
using warning_incomplete_expansion = warning_msg<35>;

using error_orphan_elif = error_msg<1>;
using error_orphan_else = error_msg<2>;
using error_orphan_endif = error_msg<3>;
using  error_eof_too_soon = error_msg<4>;
using  error_nothing_to_do = error_msg<6>;
using error_one_file_only = error_msg<7>;
using error_invalid_args = error_msg<8>;
using error_usage = error_msg<9>;
using error_too_deep = error_msg<10>;
using error_multiple_argfiles =error_msg<11>;
using error_garbage_arg = error_msg<12>;
using error_not_identifier =  error_msg<13>;
using error_unbalanced_paren = error_msg<14>;
using error_if_without_cond = error_msg<15>;
using error_cant_get_realpath = error_msg<16>;
using error_malformed_macro = error_msg<17>;
using error_mismatched_macro_args = error_msg<18>;
using error_macro_call_on_undefined =  error_msg<19>;
using error_ternary_cond_incomplete = error_msg<20>;
using error_ill_formed_expression = error_msg<21>;
using error_empty_symbol = error_msg<22>;
using error_infinite_regress= error_msg<23>;
using error_misplaced_token_paste = error_msg<24>;
using error_stringify_non_param = error_msg<25>;
using error_non_term = error_msg<26>;
using error_bad_token_paste = error_msg<27>;


using abend_cant_open_output = abend_msg<1>;
using abend_cant_open_input = abend_msg<2>;
using abend_eof_in_filename = abend_msg<3>;
using abend_confused= abend_msg<4>;
using abend_cant_read_input = abend_msg<5>;
using abend_cant_write_file= abend_msg<6>;
using abend_no_file = abend_msg<7>;
using abend_illegal_filename = abend_msg<8>;
using abend_cant_delete_file = abend_msg<9>;
using abend_cant_rename_file = abend_msg<10>;
using abend_no_tempfile = abend_msg<11>;
using abend_cant_open_dir = abend_msg<12>;
using abend_cant_read_dir = abend_msg<13>;
using abend_invalid_spin_dir = abend_msg<14>;
using abend_cant_get_cwd = abend_msg<15>;
using abend_cant_create_dir = abend_msg<16>;


using progress_summary_all_done = progress_summary_msg<1>;
using info_summary_files_reached = info_summary_msg<1>;
using info_summary_files_dropped = info_summary_msg<2>;
using info_summary_summary_dropped_lines = info_summary_msg<3>;
using info_summary_summary_changed_lines = info_summary_msg<4>;
using warning_summary_summary_errored_lines = warning_summary_msg<1>;
using warning_summary_summary_error_output = warning_summary_msg<2>;

#endif // EOF