pythonObjects.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_PYOBJECT_H
#define TRITON_PYOBJECT_H
 
#include <triton/pythonBindings.hpp>
 
#include <triton/archEnums.hpp>
#include <triton/ast.hpp>
#include <triton/basicBlock.hpp>
#include <triton/bitsVector.hpp>
#include <triton/immediate.hpp>
#include <triton/instruction.hpp>
#include <triton/memoryAccess.hpp>
#include <triton/pathConstraint.hpp>
#include <triton/register.hpp>
#include <triton/solverModel.hpp>
#include <triton/symbolicExpression.hpp>
#include <triton/symbolicVariable.hpp>
 
 
 
namespace triton {
  class Context;
 
  namespace bindings {
    namespace python {
      PyObject* PyAstNode(const triton::ast::SharedAbstractNode& node);
 
      template <typename T> PyObject* PyBitsVector(const T& op);
 
      PyObject* PyImmediate(const triton::arch::Immediate& imm);
 
      PyObject* PyBasicBlock(void);
 
      PyObject* PyBasicBlock(const triton::arch::BasicBlock& block);
 
      PyObject* PyBasicBlock(std::vector<triton::arch::Instruction>& insts);
 
      PyObject* PyInstruction(void);
 
      PyObject* PyInstruction(const triton::arch::Instruction& inst);
 
      PyObject* PyInstruction(const void* opcodes, triton::uint32 opSize);
 
      PyObject* PyInstruction(triton::uint64 addr, const void* opcodes, triton::uint32 opSize);
 
      PyObject* PyMemoryAccess(const triton::arch::MemoryAccess& mem);
 
      PyObject* PyPathConstraint(const triton::engines::symbolic::PathConstraint& pc);
 
      PyObject* PyTritonContext(void);
 
      PyObject* PyTritonContext(triton::arch::architecture_e arch);
 
      PyObject* PyTritonContextRef(triton::Context& ctx);
 
      PyObject* PyAstContext(const triton::ast::SharedAstContext& actx);
 
      PyObject* PyRegister(const triton::arch::Register& reg);
 
      PyObject* PySolverModel(const triton::engines::solver::SolverModel& model);
 
      PyObject* PySymbolicExpression(const triton::engines::symbolic::SharedSymbolicExpression& expr);
 
      PyObject* PySymbolicVariable(const triton::engines::symbolic::SharedSymbolicVariable& symVar);
 
      /* AstNode ======================================================== */
 
      typedef struct {
        PyObject_HEAD
        triton::ast::SharedAbstractNode node;
      } AstNode_Object;
 
      extern PyTypeObject AstNode_Type;
 
      /* BitsVector ====================================================== */
 
      typedef struct {
        PyObject_HEAD
        triton::arch::BitsVector* bv;
      } BitsVector_Object;
 
      extern PyTypeObject BitsVector_Type;
 
      /* Basic Block ===================================================== */
 
      typedef struct {
        PyObject_HEAD
        triton::arch::BasicBlock* block;
      } BasicBlock_Object;
 
      extern PyTypeObject BasicBlock_Type;
 
      /* Immediate ====================================================== */
 
      typedef struct {
        PyObject_HEAD
        triton::arch::Immediate* imm;
      } Immediate_Object;
 
      extern PyTypeObject Immediate_Type;
 
      /* Instruction ==================================================== */
 
      typedef struct {
        PyObject_HEAD
        triton::arch::Instruction* inst;
      } Instruction_Object;
 
      extern PyTypeObject Instruction_Type;
 
      /* MemoryAccess =================================================== */
 
      typedef struct {
        PyObject_HEAD
        triton::arch::MemoryAccess* mem;
      } MemoryAccess_Object;
 
      extern PyTypeObject MemoryAccess_Type;
 
      /* PathConstraint ================================================= */
 
      typedef struct {
        PyObject_HEAD
        triton::engines::symbolic::PathConstraint* pc; 
      } PathConstraint_Object;
 
      extern PyTypeObject PathConstraint_Type;
 
      /* Register ======================================================= */
 
      typedef struct {
        PyObject_HEAD
        triton::arch::Register* reg; 
      } Register_Object;
 
      extern PyTypeObject Register_Type;
 
      /* TrytonContext ======================================================= */
 
      typedef struct {
        PyObject_HEAD
        triton::Context* ctx; 
        bool ref;             
        PyObject* regAttr;    
      } TritonContext_Object;
 
      extern PyTypeObject TritonContextObject_Type;
 
      /* AstContext ======================================================= */
 
      typedef struct {
        PyObject_HEAD
        triton::ast::SharedAstContext actx;
      } AstContext_Object;
 
      extern PyTypeObject AstContextObject_Type;
 
      /* SolverModel ==================================================== */
 
      typedef struct {
        PyObject_HEAD
        triton::engines::solver::SolverModel* model; 
      } SolverModel_Object;
 
      extern PyTypeObject SolverModel_Type;
 
      /* SymbolicExpression ============================================= */
 
      typedef struct {
        PyObject_HEAD
        triton::engines::symbolic::SharedSymbolicExpression symExpr;
      } SymbolicExpression_Object;
 
      extern PyTypeObject SymbolicExpression_Type;
 
      /* SymbolicVariable =============================================== */
 
      typedef struct {
        PyObject_HEAD
        triton::engines::symbolic::SharedSymbolicVariable symVar;
      } SymbolicVariable_Object;
 
      extern PyTypeObject SymbolicVariable_Type;
 
    };
  };
};
 
 
#define PyAstNode_AsAstNode(v) (((triton::bindings::python::AstNode_Object*)(v))->node)
 
#define PyBitsVector_Check(v) ((v)->ob_type == &triton::bindings::python::BitsVector_Type)
 
#define PyBitsVector_AsBitsVector(v) (((triton::bindings::python::BitsVector_Object*)(v))->bv)
 
#define PyBasicBlock_Check(v) ((v)->ob_type == &triton::bindings::python::BasicBlock_Type)
 
#define PyBasicBlock_AsBasicBlock(v) (((triton::bindings::python::BasicBlock_Object*)(v))->block)
 
#define PyImmediate_Check(v) ((v)->ob_type == &triton::bindings::python::Immediate_Type)
 
#define PyImmediate_AsImmediate(v) (((triton::bindings::python::Immediate_Object*)(v))->imm)
 
#define PyInstruction_Check(v) ((v)->ob_type == &triton::bindings::python::Instruction_Type)
 
#define PyInstruction_AsInstruction(v) (((triton::bindings::python::Instruction_Object*)(v))->inst)
 
#define PyMemoryAccess_Check(v) ((v)->ob_type == &triton::bindings::python::MemoryAccess_Type)
 
#define PyMemoryAccess_AsMemoryAccess(v) (((triton::bindings::python::MemoryAccess_Object*)(v))->mem)
 
#define PyPathConstraint_Check(v) ((v)->ob_type == &triton::bindings::python::PathConstraint_Type)
 
#define PyPathConstraint_AsPathConstraint(v) (((triton::bindings::python::PathConstraint_Object*)(v))->pc)
 
#define PyTritonContext_Check(v) ((v)->ob_type == &triton::bindings::python::TritonContext_Type)
 
#define PyTritonContext_AsTritonContext(v) (((triton::bindings::python::TritonContext_Object*)(v))->ctx)
 
#define PyAstContext_Check(v) ((v)->ob_type == &triton::bindings::python::AstContext_Type)
 
#define PyAstContext_AsAstContext(v) (((triton::bindings::python::AstContext_Object*)(v))->actx)
 
#define PyRegister_Check(v) ((v)->ob_type == &triton::bindings::python::Register_Type)
 
#define PyRegister_AsRegister(v) (((triton::bindings::python::Register_Object*)(v))->reg)
 
#define PySolverModel_Check(v) ((v)->ob_type == &triton::bindings::python::SolverModel_Type)
 
#define PySolverModel_AsSolverModel(v) (((triton::bindings::python::SolverModel_Object*)(v))->model)
 
#define PyAstNode_Check(v) ((v)->ob_type == &triton::bindings::python::AstNode_Type)
 
#define PySymbolicExpression_Check(v) ((v)->ob_type == &triton::bindings::python::SymbolicExpression_Type)
 
#define PySymbolicExpression_AsSymbolicExpression(v) (((triton::bindings::python::SymbolicExpression_Object*)(v))->symExpr)
 
#define PySymbolicVariable_Check(v) ((v)->ob_type == &triton::bindings::python::SymbolicVariable_Type)
 
#define PySymbolicVariable_AsSymbolicVariable(v) (((triton::bindings::python::SymbolicVariable_Object*)(v))->symVar)
 
#endif /* TRITON_PYOBJECT_H */