error.h

Go to the documentation of this file.

// This file is part of MARTY.
// 
// MARTY 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.
// 
// MARTY 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 MARTY. If not, see <https://www.gnu.org/licenses/>.

#ifndef ERROR_H_INCLUDED
#define ERROR_H_INCLUDED

#include <iostream>
#include <string_view>
#include <csignal>
#include "options.h"

namespace cslError{

    enum Error{
        AbstractFuncCalled=1, 
        BadCopyConstructor, 
        ElementSequence, 
        OutOfBounds, 
        EvalNotValued, 
        UndefinedBehaviour, 
        ContractDummy, 
        ContractionMismatch, 
        SymmetryMismatch, 
        UnknownProperty, 
        InvalidITensor, 
        InvalidIndicialParent,  
        InvalidIndicialSum, 
        BadDependency, 
        BadType,  
        BadSymmetry, 
        BadContraction,  
        UnknownEquation, 
        BadPropertySetting,  
        ArbitraryEvaluated, 
        ComparingNotDummy,  
        BadCommutationProp,  
        NegativeGroupDimension,  
        NoContractionProperty,  
        BadSelfContraction, 
        BadFieldInitialization, 
        OperatorNotImplemented, 
        BadOperator, 
    };

    enum Warning{
        UnknownType=0, 
        InvalidDimension, 
        FactorialFloat, 
        NotValued, 
        Infinity, 
        CopyingBuildingBlock, 
        NCharatersNotImplemented, 
    };

}

namespace csl {

#ifdef DEBUG

constexpr static const bool STOP_ERROR_DEBUG_MODE = true;
#else
constexpr static const bool STOP_ERROR_DEBUG_MODE = true;
#endif

template<typename T>
inline void callError(cslError::Error error, const std::string& caller, T spec)
{
    using namespace cslError;
    std::cout<<"Error "<<(int)error<<": ";
    switch(error)
    {
        case AbstractFuncCalled:
               std::cout<<"Abstract function \""<<caller<<"\" called. Should not be, virtual function.\n"; break;
        case BadCopyConstructor:
               std::cout<<"Copy constructor called with wrong type in "<<caller<<": "<<spec<<".\n"; break;
        case OutOfBounds:
               std::cout<<"Index "<<spec<<" out of bounds in "<<caller<<".\n"; break;
        case ElementSequence:
               std::cout<<"Initializing a vector element with a sequence in "<<caller<<".\n"; break;
        case EvalNotValued:
               std::cout<<"Evaluating the value of non valued Abstract in "<<caller<<".\n"; break;
        case UndefinedBehaviour:
               std::cout<<"Undefined behaviour in "<<caller<<"\n."; break;
        case ContractDummy:
               std::cout<<"Contracting dummy index in "<<caller<<": "<<spec<<std::endl; break;
        case ContractionMismatch: 
               std::cout<<"Mismatch in contraction ("<<caller<<"): "<<spec<<std::endl; break;
        case SymmetryMismatch: 
               std::cout<<"Mismatch in symmetry in "<<caller<<".\n"; break;
        case UnknownProperty:
               std::cout<<"Unknown property in "<<caller<<": "<<spec<<std::endl; break;
        case InvalidITensor:
               std::cout<<"Bad set of indices in creation of TensorElement in "<<caller<<std::endl; break;
        case InvalidIndicialParent:
               std::cout<<"Invalid initialization of TensorParent in "<<caller<<": bad tensor.\n"; break;
        case InvalidIndicialSum:
               std::cout<<"Invalid sum of indicial objects in "<<caller<<std::endl; break;
        case BadDependency:
               std::cout<<"Bad dependency set for "<<spec<<" in "<<caller<<"\n"; break;
        case BadType: 
               std::cout<<"Bad type of expression sent in "<<caller<<": requires "<<spec<<".\n"; break;
        case BadSymmetry :
               std::cout<<"Bad symmetry set in TensorParent (wrong dimension) in "<<caller<<".\n"; break;
        case BadContraction:
               std::cout<<"Bad contraction of indices in "<<caller<<": "<<spec<<".\n"; break;
        case UnknownEquation:
               std::cout<<"Unknown type of equation in "<<caller<<": "<<spec<<".\n"; break;
        case BadPropertySetting:
               std::cout<<"Setting a property with something else than an equality in "<<caller<<": "<<spec<<".\n"; break;
        case ArbitraryEvaluated:
               std::cout<<"An arbitrary abstract has been evaluated from "<<caller<<". Should not be.\n"; break;
        case ComparingNotDummy:
               std::cout<<"Comparing non-dummy Abstract in "<<caller<<".\n"; break;
        case BadCommutationProp:
               std::cout<<"Setting commutability property of an object for which it is not possible in "<<caller<<".\n"; break;
        case NegativeGroupDimension:
               std::cout<<"Negative dimension encountered in "<<caller<<": "<<spec<<std::endl; break;
        case NoContractionProperty:
               std::cout<<"Calling a special contraction of TensorElement in "<<caller<<", but there is no contraction.\n"; break;
        case BadSelfContraction:
               std::cout<<"Initializing badly a self-contraction property of TensorParent in "<<caller<<".\n"; break;
        case BadFieldInitialization:
               std::cout<<"Bas initialization of field in "<<caller<<": need a vector of the right space.\n"; break;

        case OperatorNotImplemented:
               std::cout<<"Rules of the operator are not implemented in "<<caller<<".\n"; break;
        case BadOperator:
               std::cout<<"Bad initialization of operator in "<<caller<<".\n"; break;
               
        default:
               std::cout<<"SmError "<<(int)error<<" not recognized.\n";
    }
    if (STOP_ERROR_DEBUG_MODE)
        std::raise(SIGSEGV);
    else if (option::errorStopsProgram)
        exit((int)error);
}
void callError(cslError::Error error, const std::string& caller);

template<typename T>
inline void callWarning(cslError::Warning warning, const std::string& caller, T spec)
{
    using namespace cslError;
    std::cout<<"Warning "<<(int)warning<<": ";
    switch(warning)
    {
        case UnknownType:
               std::cout<<"ScmType "<<" unknown in function \""<<caller<<"\".\n"; break;
        case InvalidDimension:
               std::cout<<"Invalid dimension "<<spec<<" in function "<<caller<<".\n"; break;
        case FactorialFloat:
               std::cout<<"Float value encountered in Factorial. Replacing by rounded value.\n"; break;
        case NotValued:
               std::cout<<"Evaluating non valued in "<<caller<<". Replacing by 0.\n"; break;
        case Infinity:
               std::cout<<"Infinite result found in "<<caller<<".\n"; break;
        case CopyingBuildingBlock:
               std::cout<<"Copying building block in "<<caller<<": "<<spec<<"\n"; break;
        case NCharatersNotImplemented:
               std::cout<<"The function getNCharacters() is not implemented for type "<<spec<<" in "<<caller<<".\n"; break;

        default:
               std::cout<<"SmWarning "<<(int)warning<<" not recognized.\n";
    }
}

} // End of namespace csl


enum class CSLError{

    AbstractCallError,  //Raised when an abstract (not implemented) fucntion is called.
    AttributeError,     //Raised when attribute assignment or reference fails.
    EOFError,           //Raised when the input() functions hits end-of-file condition.
    FloatingPointError, //Raised when a floating point operation fails.
    GeneratorExit,      //Raise when a generator's close() method is called.
    IndexError,         //Raised when index of a sequence is out of range.
    IOError,            //Raised when a file is not found.
    KeyError,           //Raised when a key is not found in a dictionary.
    MathError,    
    NameError,          //Raised when a variable is not found in local or global scope.
    NotImplementedError,//Raised by abstract methods.
    OverflowError,      //Raised when result of an arithmetic operation is too large to be represented.
    RuntimeError,       //Raised when an error does not fall under any other category.
    SyntaxError,        //Raised by parser when syntax error is encountered.
    TypeError,          //Raised when a function or operation is applied to an object of incorrect type.
    ValueError,         //Raised when a function gets argument of correct type but improper value.
    ZeroDivisionError   //Raised when second operand of division or modulo operation is zero.
};

std::ostream& operator<<(std::ostream& fout, CSLError error);

void CallErrorImpl(CSLError          error,
                   std::string_view func,
                   std::string_view file,
                   int              line);

void CallErrorImpl(CSLError          error,
                   std::string_view func,
                   std::string_view file,
                  int              line,
                   std::string_view message);

#define CSL_ASSERT(cond, error)\
    if (not (cond)) {\
        CallErrorImpl(error, __func__, __FILE__, __LINE__);\
    }
#define CSL_ASSERT_SPEC(cond, error, message)\
    if (not (cond)) {\
        CallErrorImpl(error, __func__, __FILE__, __LINE__, message);\
    }

#define CALL_SMERROR(error)\
    CallErrorImpl(error, __func__, __FILE__, __LINE__)

#define CALL_SMERROR_SPEC(error, message)\
    CallErrorImpl(error, __func__, __FILE__, __LINE__, message)


#endif