error.cpp

Go to the documentation of this file.

/*****************************************************************************
    NumeRe: Framework fuer Numerische Rechnungen
    Copyright (C) 2017  Erik Haenel et al.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program 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 for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
 
#include "error.hpp"
#include "../utils/tools.hpp"
#include "../strings/stringdatastructures.hpp"
#include "../../kernel.hpp"
#include "../maths/matdatastructures.hpp"
 
size_t SyntaxError::invalid_position = std::string::npos;
int SyntaxError::invalid_index = INT_MIN;
Assertion _assertionHandler;
static std::string sLastErrorMessage;
static ErrorType nLastErrorType;
 
 
 
ErrorType getErrorType(std::exception_ptr e_ptr)
{
    sLastErrorMessage.clear();
 
    try
    {
        rethrow_exception(e_ptr);
    }
    catch (mu::Parser::exception_type& e)
    {
        // Parser exception
        sLastErrorMessage = e.GetMsg();
        return (nLastErrorType = TYPE_MATHERROR);
    }
    catch (const std::bad_alloc& e)
    {
        sLastErrorMessage = _lang.get("ERR_STD_BA_HEAD") + "\n" + e.what();
        return (nLastErrorType = TYPE_CRITICALERROR);
    }
    catch (const std::exception& e)
    {
        // C++ Standard exception
        sLastErrorMessage = _lang.get("ERR_STD_INTERNAL_HEAD") + "\n" + e.what();
        return (nLastErrorType = TYPE_INTERNALERROR);
    }
    catch (SyntaxError& e)
    {
        // Internal exception
        if (e.errorcode == SyntaxError::PROCESS_ABORTED_BY_USER)
        {
            // the user pressed ESC
            return (nLastErrorType = TYPE_ABORT);
        }
        else
        {
            if (e.getToken().length() && (e.errorcode == SyntaxError::PROCEDURE_THROW || e.errorcode == SyntaxError::LOOP_THROW))
            {
                sLastErrorMessage = e.getToken();
                return (nLastErrorType = TYPE_CUSTOMERROR);
            }
            else if (e.errorcode == SyntaxError::ASSERTION_ERROR)
            {
                sLastErrorMessage = _lang.get("ERR_NR_" + toString((int)e.errorcode) + "_0_*", e.getToken(),
                                              toString(e.getIndices()[0]), toString(e.getIndices()[1]),
                                              toString(e.getIndices()[2]), toString(e.getIndices()[3]));
                sLastErrorMessage = sLastErrorMessage;
                return (nLastErrorType = TYPE_ASSERTIONERROR);
            }
            else
            {
                sLastErrorMessage = _lang.get("ERR_NR_" + toString((int)e.errorcode) + "_0_*", e.getToken(),
                                              toString(e.getIndices()[0]), toString(e.getIndices()[1]),
                                              toString(e.getIndices()[2]), toString(e.getIndices()[3]));
 
                // This error message does not exist
                if (sLastErrorMessage.substr(0, 7) == "ERR_NR_")
                    sLastErrorMessage = _lang.get("ERR_GENERIC_0", toString((int)e.errorcode));
 
                return (nLastErrorType = TYPE_SYNTAXERROR);
            }
        }
    }
    catch (...)
    {
        sLastErrorMessage = _lang.get("ERR_CATCHALL_HEAD");
        return (nLastErrorType = TYPE_GENERICERROR);
    }
 
    return (nLastErrorType = TYPE_NOERROR);
}
 
 
std::string getLastErrorMessage()
{
    return sLastErrorMessage;
}
 
 
ErrorType getLastErrorType()
{
    return nLastErrorType;
}
 
 
std::string errorTypeToString(ErrorType e)
{
    switch (e)
    {
        case TYPE_NOERROR:
            return "none";
        case TYPE_ABORT:
            return "abort";
        case TYPE_MATHERROR:
            return "expression";
        case TYPE_SYNTAXERROR:
            return "error";
        case TYPE_ASSERTIONERROR:
            return "assertion";
        case TYPE_CUSTOMERROR:
            return "thrown";
        case TYPE_INTERNALERROR:
            return "internal";
        case TYPE_CRITICALERROR:
            return "critical";
        case TYPE_GENERICERROR:
            return "generic";
    }
 
    return "none";
}
 
 
void Assertion::assertionFail()
{
    stats.failed();
    throw SyntaxError(SyntaxError::ASSERTION_ERROR, sAssertedExpression, findCommand(sAssertedExpression, "assert").nPos+7);
}
 
 
void Assertion::reset()
{
    if (assertionMode)
    {
        assertionMode = false;
        sAssertedExpression.clear();
    }
}
 
 
void Assertion::resetStats()
{
    stats.reset();
}
 
 
void Assertion::enable(const std::string& sExpr)
{
    sAssertedExpression = sExpr;
    assertionMode = true;
}
 
 
void Assertion::checkAssertion(mu::value_type* v, int nNum)
{
    // Only do something, if the assertion mode is
    // active
    if (assertionMode)
    {
        for (int i = 0; i < nNum; i++)
        {
            // If a single value is zero,
            // throw the assertion error
            if (v[i] == 0.0)
                assertionFail();
        }
 
        stats.succeeded();
    }
}
 
 
void Assertion::checkAssertion(const Matrix& _mMatrix)
{
    // Only do something, if the assertion mode is
    // active
    if (assertionMode)
    {
        for (const mu::value_type& val : _mMatrix.data())
        {
            // If a single value is zero,
            // throw the assertion error
            if (val == 0.0)
                assertionFail();
        }
 
        stats.succeeded();
    }
}
 
 
void Assertion::checkAssertion(const StringResult& strRes)
{
    // Only do something, if the assertion mode is
    // active and the strings are not only logicals
    if (assertionMode && !strRes.bOnlyLogicals)
    {
        for (size_t i = 0; i < strRes.vResult.size(); i++)
        {
            if (strRes.vResult[i] == "\"\"")
                assertionFail();
            else if (strRes.vNoStringVal[i])
            {
                NumeReKernel::getInstance()->getParser().SetExpr(strRes.vResult[i]);
 
                if (NumeReKernel::getInstance()->getParser().Eval() == 0.0)
                    assertionFail();
            }
        }
 
        stats.succeeded();
    }
}
 
 
AssertionStats Assertion::getStats() const
{
    return stats;
}