exceptions.hpp

Go to the documentation of this file.

 
/*
**  Copyright (C) - Triton
**
**  This program is under the terms of the Apache License 2.0.
*/
 
#ifndef TRITON_EXCEPTIONS_H
#define TRITON_EXCEPTIONS_H
 
#include <exception>
#include <string>
 
#include <triton/dllexport.hpp>
#include <triton/tritonTypes.hpp>
 
 
 
namespace triton {
  namespace exceptions {
    class Exception : public std::exception {
      protected:
        std::string message;
 
      public:
        TRITON_EXPORT Exception(const char* message) {
          this->message = std::string(message);
        };
 
        TRITON_EXPORT Exception(const std::string& message) {
          this->message = message;
        };
 
        TRITON_EXPORT virtual ~Exception() throw() {
        };
 
        TRITON_EXPORT const char* what() const throw () {
          return this->message.c_str();
        };
    };
 
 
    class Engines : public triton::exceptions::Exception {
      public:
        TRITON_EXPORT Engines(const char* message) : triton::exceptions::Exception(message) {};
 
        TRITON_EXPORT Engines(const std::string& message) : triton::exceptions::Exception(message) {};
    };
 
 
    class SymbolicEngine : public triton::exceptions::Engines {
      public:
        TRITON_EXPORT SymbolicEngine(const char* message) : triton::exceptions::Engines(message) {};
 
        TRITON_EXPORT SymbolicEngine(const std::string& message) : triton::exceptions::Engines(message) {};
    };
 
 
    class SymbolicExpression : public triton::exceptions::SymbolicEngine {
      public:
        TRITON_EXPORT SymbolicExpression(const char* message) : triton::exceptions::SymbolicEngine(message) {};
 
        TRITON_EXPORT SymbolicExpression(const std::string& message) : triton::exceptions::SymbolicEngine(message) {};
    };
 
 
    class SymbolicSimplification : public triton::exceptions::SymbolicEngine {
      public:
        TRITON_EXPORT SymbolicSimplification(const char* message) : triton::exceptions::SymbolicEngine(message) {};
 
        TRITON_EXPORT SymbolicSimplification(const std::string& message) : triton::exceptions::SymbolicEngine(message) {};
    };
 
 
    class SymbolicVariable : public triton::exceptions::SymbolicEngine {
      public:
        TRITON_EXPORT SymbolicVariable(const char* message) : triton::exceptions::SymbolicEngine(message) {};
 
        TRITON_EXPORT SymbolicVariable(const std::string& message) : triton::exceptions::SymbolicEngine(message) {};
    };
 
 
    class PathConstraint : public triton::exceptions::SymbolicEngine {
      public:
        TRITON_EXPORT PathConstraint(const char* message) : triton::exceptions::SymbolicEngine(message) {};
 
        TRITON_EXPORT PathConstraint(const std::string& message) : triton::exceptions::SymbolicEngine(message) {};
    };
 
 
    class PathManager : public triton::exceptions::SymbolicEngine {
      public:
        TRITON_EXPORT PathManager(const char* message) : triton::exceptions::SymbolicEngine(message) {};
 
        TRITON_EXPORT PathManager(const std::string& message) : triton::exceptions::SymbolicEngine(message) {};
    };
 
 
    class TaintEngine : public triton::exceptions::Engines {
      public:
        TRITON_EXPORT TaintEngine(const char* message) : triton::exceptions::Engines(message) {};
 
        TRITON_EXPORT TaintEngine(const std::string& message) : triton::exceptions::Engines(message) {};
    };
 
 
    class SynthesizerEngine : public triton::exceptions::Engines {
      public:
        TRITON_EXPORT SynthesizerEngine(const char* message) : triton::exceptions::Engines(message) {};
 
        TRITON_EXPORT SynthesizerEngine(const std::string& message) : triton::exceptions::Engines(message) {};
    };
 
 
    class LiftingEngine : public triton::exceptions::Engines {
      public:
        TRITON_EXPORT LiftingEngine(const char* message) : triton::exceptions::Engines(message) {};
 
        TRITON_EXPORT LiftingEngine(const std::string& message) : triton::exceptions::Engines(message) {};
    };
 
 
    class SolverEngine : public triton::exceptions::Engines {
      public:
        TRITON_EXPORT SolverEngine(const char* message) : triton::exceptions::Engines(message) {};
 
        TRITON_EXPORT SolverEngine(const std::string& message) : triton::exceptions::Engines(message) {};
    };
 
 
    class SolverModel : public triton::exceptions::SolverEngine {
      public:
        TRITON_EXPORT SolverModel(const char* message) : triton::exceptions::SolverEngine(message) {};
 
        TRITON_EXPORT SolverModel(const std::string& message) : triton::exceptions::SolverEngine(message) {};
    };
 
 
    class Context : public triton::exceptions::Exception {
      public:
        TRITON_EXPORT Context(const char* message) : triton::exceptions::Exception(message) {};
 
        TRITON_EXPORT Context(const std::string& message) : triton::exceptions::Exception(message) {};
    };
 
 
    class Architecture : public triton::exceptions::Exception {
      public:
        TRITON_EXPORT Architecture(const char* message) : triton::exceptions::Exception(message) {};
 
        TRITON_EXPORT Architecture(const std::string& message) : triton::exceptions::Exception(message) {};
    };
 
 
    class BitsVector : public triton::exceptions::Architecture {
      public:
        TRITON_EXPORT BitsVector(const char* message) : triton::exceptions::Architecture(message) {};
 
        TRITON_EXPORT BitsVector(const std::string& message) : triton::exceptions::Architecture(message) {};
    };
 
 
    class Immediate : public triton::exceptions::Architecture {
      public:
        TRITON_EXPORT Immediate(const char* message) : triton::exceptions::Architecture(message) {};
 
        TRITON_EXPORT Immediate(const std::string& message) : triton::exceptions::Architecture(message) {};
    };
 
 
    class Register : public triton::exceptions::Architecture {
      public:
        TRITON_EXPORT Register(const char* message) : triton::exceptions::Architecture(message) {};
 
        TRITON_EXPORT Register(const std::string& message) : triton::exceptions::Architecture(message) {};
    };
 
 
    class MemoryAccess : public triton::exceptions::Architecture {
      public:
        TRITON_EXPORT MemoryAccess(const char* message) : triton::exceptions::Architecture(message) {};
 
        TRITON_EXPORT MemoryAccess(const std::string& message) : triton::exceptions::Architecture(message) {};
    };
 
 
    class OperandWrapper : public triton::exceptions::Architecture {
      public:
        TRITON_EXPORT OperandWrapper(const char* message) : triton::exceptions::Architecture(message) {};
 
        TRITON_EXPORT OperandWrapper(const std::string& message) : triton::exceptions::Architecture(message) {};
    };
 
 
    class Instruction : public triton::exceptions::Architecture {
      public:
        TRITON_EXPORT Instruction(const char* message) : triton::exceptions::Architecture(message) {};
 
        TRITON_EXPORT Instruction(const std::string& message) : triton::exceptions::Architecture(message) {};
    };
 
 
    class BasicBlock : public triton::exceptions::Architecture {
      public:
        TRITON_EXPORT BasicBlock(const char* message) : triton::exceptions::Architecture(message) {};
 
        TRITON_EXPORT BasicBlock(const std::string& message) : triton::exceptions::Architecture(message) {};
    };
 
 
    class Cpu : public triton::exceptions::Architecture {
      public:
        TRITON_EXPORT Cpu(const char* message) : triton::exceptions::Architecture(message) {};
 
        TRITON_EXPORT Cpu(const std::string& message) : triton::exceptions::Architecture(message) {};
    };
 
 
    class ArmOperandProperties : public triton::exceptions::Architecture {
      public:
        TRITON_EXPORT ArmOperandProperties(const char* message) : triton::exceptions::Architecture(message) {};
 
        TRITON_EXPORT ArmOperandProperties(const std::string& message) : triton::exceptions::Architecture(message) {};
    };
 
 
    class AArch64OperandProperties : public triton::exceptions::Architecture {
      public:
        TRITON_EXPORT AArch64OperandProperties(const char* message) : triton::exceptions::Architecture(message) {};
 
        TRITON_EXPORT AArch64OperandProperties(const std::string& message) : triton::exceptions::Architecture(message) {};
    };
 
 
    class IrBuilder : public triton::exceptions::Architecture {
      public:
        TRITON_EXPORT IrBuilder(const char* message) : triton::exceptions::Architecture(message) {};
 
        TRITON_EXPORT IrBuilder(const std::string& message) : triton::exceptions::Architecture(message) {};
    };
 
 
    class Disassembly : public triton::exceptions::Cpu {
      public:
        TRITON_EXPORT Disassembly(const char* message) : triton::exceptions::Cpu(message) {};
 
        TRITON_EXPORT Disassembly(const std::string& message) : triton::exceptions::Cpu(message) {};
    };
 
 
    class Semantics : public triton::exceptions::Cpu {
      public:
        TRITON_EXPORT Semantics(const char* message) : triton::exceptions::Cpu(message) {};
 
        TRITON_EXPORT Semantics(const std::string& message) : triton::exceptions::Cpu(message) {};
    };
 
 
    class Ast : public triton::exceptions::Exception {
      public:
        TRITON_EXPORT Ast(const char* message) : triton::exceptions::Exception(message) {};
 
        TRITON_EXPORT Ast(const std::string& message) : triton::exceptions::Exception(message) {};
    };
 
 
    class AstRepresentation : public triton::exceptions::Ast {
      public:
        TRITON_EXPORT AstRepresentation(const char* message) : triton::exceptions::Ast(message) {};
 
        TRITON_EXPORT AstRepresentation(const std::string& message) : triton::exceptions::Ast(message) {};
    };
 
 
    class AstLifting : public triton::exceptions::Ast {
      public:
        TRITON_EXPORT AstLifting(const char* message) : triton::exceptions::Ast(message) {};
 
        TRITON_EXPORT AstLifting(const std::string& message) : triton::exceptions::Ast(message) {};
    };
 
 
    class Bindings : public triton::exceptions::Exception {
      public:
        TRITON_EXPORT Bindings(const char* message) : triton::exceptions::Exception(message) {};
 
        TRITON_EXPORT Bindings(const std::string& message) : triton::exceptions::Exception(message) {};
    };
 
 
    class Callbacks : public triton::exceptions::Exception {
      public:
        TRITON_EXPORT Callbacks(const char* message) : triton::exceptions::Exception(message) {};
 
        TRITON_EXPORT Callbacks(const std::string& message) : triton::exceptions::Exception(message) {};
    };
 
    class PyCallbacks : public triton::exceptions::Exception {
    public:
      TRITON_EXPORT PyCallbacks() : triton::exceptions::Exception("exception info is stored in python state") {};
    };
 
  };
};
 
#endif /* TRITON_EXCEPTIONS_HPP */