Quelle ErrorHandling.h Sprache: C

/*
* Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.  Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/

#ifndef ErrorHandling_h
#define ErrorHandling_h

#include <stdexcept>

#include "SourceCodePos.h"
#include "tstrings.h"

//
// Exception handling helpers. Allow transparent exception logging.
// Use as follows:
//
//  void foo () {
//      JP_TRY;
//
//      if (!do_something()) {
//          JP_THROW("do_something() failed");
//      }
//
//      JP_CATCH_ALL;
//  }
//

// Logs std::exception caught at 'pos'.
void reportError(const SourceCodePos& pos, const std::runtime_error& e);
// Logs unknown exception caught at 'pos'.
// Assumed to be called from catch (...) {}
void reportUnknownError(const SourceCodePos& pos);

std::string makeMessage(const std::runtime_error& e, const SourceCodePos& pos);

std::string joinErrorMessages(const std::string& a, const std::string& b);

std::string lastCRTError();

class JpErrorBase {
public:
    virtual const char* rawMessage() const throw() = 0;
};

template <class Base>
class JpError: public JpErrorBase, public Base {
public:
    JpError(const Base& e, const SourceCodePos& pos):
                                        Base(e), msg(::makeMessage(e, pos)) {
    }

    ~JpError() throw() {
    }

    // override Base::what()
    const char* what() const throw() {
        return msg.c_str();
    }

    // override JpErrorBase
    const char* rawMessage() const throw() {
        return Base::what();
    }
private:
    // Assert Base is derived from std::runtime_error
    enum { isDerivedFromStdException =
                        sizeof(static_cast<std::runtime_error*>((Base*)0)) };

    std::string msg;
};

template <class T>
inline JpError<T> makeException(const T& obj, const SourceCodePos& p) {
    return JpError<T>(obj, p);
}

inline JpError<std::runtime_error> makeException(
                            const std::string& msg, const SourceCodePos& p) {
    return JpError<std::runtime_error>(std::runtime_error(msg), p);
}

inline JpError<std::runtime_error> makeException(
                        const tstrings::any& msg, const SourceCodePos& p) {
    return makeException(msg.str(), p);
}

inline JpError<std::runtime_error> makeException(
                    std::string::const_pointer msg, const SourceCodePos& p) {
    return makeException(std::string(msg), p);
}

#define JP_REPORT_ERROR(e)          reportError(JP_SOURCE_CODE_POS, e)
#define JP_REPORT_UNKNOWN_ERROR     reportUnknownError(JP_SOURCE_CODE_POS)

// Redefine locally in cpp file(s) if need more handling than just reporting
#define JP_HANDLE_ERROR(e)          JP_REPORT_ERROR(e)
#define JP_HANDLE_UNKNOWN_ERROR     JP_REPORT_UNKNOWN_ERROR

#define JP_TRY                              \
        try                                 \
        {                                   \
            do {} while(0)

#define JP_DEFAULT_CATCH_EXCEPTIONS         \
        JP_CATCH_STD_EXCEPTION              \
        JP_CATCH_UNKNOWN_EXCEPTION

#define JP_CATCH_EXCEPTIONS                 \
        JP_DEFAULT_CATCH_EXCEPTIONS

#define JP_CATCH_ALL                        \
        }                                   \
        JP_CATCH_EXCEPTIONS                 \
        do {} while(0)

#define JP_CATCH_STD_EXCEPTION              \
        catch (const std::runtime_error& e) \
        {                                   \
            JP_HANDLE_ERROR(e);             \
        }

#define JP_CATCH_UNKNOWN_EXCEPTION          \
        catch (...)                         \
        {                                   \
            JP_HANDLE_UNKNOWN_ERROR;        \
        }

#define JP_THROW(e) throw makeException((e), JP_SOURCE_CODE_POS)

#define JP_NO_THROW(expr) \
    JP_TRY; \
    expr; \
    JP_CATCH_ALL

#endif // #ifndef ErrorHandling_h

quality92%

¤ Dauer der Verarbeitung: 0.13 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.