ast.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_AST_H
#define TRITON_AST_H
 
#include <deque>
#include <memory>
#include <ostream>
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
#include <triton/astEnums.hpp>
#include <triton/coreUtils.hpp>
#include <triton/cpuSize.hpp>
#include <triton/dllexport.hpp>
#include <triton/exceptions.hpp>
#include <triton/tritonTypes.hpp>
 
 
 
namespace triton {
  /* Forward declarations */
  namespace engines {
    namespace symbolic {
      class SymbolicExpression;
      using SharedSymbolicExpression = std::shared_ptr<triton::engines::symbolic::SymbolicExpression>;
 
      class SymbolicVariable;
      using SharedSymbolicVariable = std::shared_ptr<triton::engines::symbolic::SymbolicVariable>;
    };
  };
 
  namespace ast {
    class AstContext;
    class AbstractNode;
 
    using SharedAbstractNode = std::shared_ptr<triton::ast::AbstractNode>;
 
    using WeakAbstractNode = std::weak_ptr<triton::ast::AbstractNode>;
 
    using SharedAstContext = std::shared_ptr<triton::ast::AstContext>;
 
    class AbstractNode : public std::enable_shared_from_this<AbstractNode> {
      private:
        virtual void initHash(void) = 0;
 
      protected:
        triton::uint32 level;
 
        triton::ast::ast_e type;
 
        std::vector<SharedAbstractNode> children;
 
        // This structure counter the number of use of a given parent as a node may have
        // multiple time the same parent: eg. xor rax rax
        std::unordered_map<AbstractNode*, std::pair<triton::uint32, WeakAbstractNode>> parents;
 
        triton::uint32 size;
 
        triton::uint512 eval;
 
        triton::uint512 hash;
 
        bool symbolized;
 
        bool logical;
 
        bool array;
 
        SharedAstContext ctxt;
 
      public:
        TRITON_EXPORT AbstractNode(triton::ast::ast_e type, const SharedAstContext& ctxt);
 
        TRITON_EXPORT virtual ~AbstractNode();
 
        TRITON_EXPORT SharedAstContext getContext(void) const;
 
        TRITON_EXPORT triton::ast::ast_e getType(void) const;
 
        TRITON_EXPORT triton::uint32 getBitvectorSize(void) const;
 
        TRITON_EXPORT triton::uint512 getBitvectorMask(void) const;
 
        TRITON_EXPORT bool isArray(void) const;
 
        TRITON_EXPORT bool isSigned(void) const;
 
        TRITON_EXPORT bool isSymbolized(void) const;
 
        TRITON_EXPORT bool isLogical(void) const;
 
        TRITON_EXPORT bool hasSameConcreteValueAndTypeAs(const SharedAbstractNode& other) const;
 
        TRITON_EXPORT bool canReplaceNodeWithoutUpdate(const SharedAbstractNode& other) const;
 
        TRITON_EXPORT bool equalTo(const SharedAbstractNode& other) const;
 
        TRITON_EXPORT triton::uint32 getLevel(void) const;
 
        TRITON_EXPORT triton::uint512 getHash(void) const;
 
        TRITON_EXPORT triton::uint512 evaluate(void) const;
 
        void initParents(void);
 
        TRITON_EXPORT std::vector<SharedAbstractNode>& getChildren(void);
 
        TRITON_EXPORT std::vector<SharedAbstractNode> getParents(void);
 
        TRITON_EXPORT void removeParent(AbstractNode* p);
 
        TRITON_EXPORT void setParent(AbstractNode* p);
 
        TRITON_EXPORT void setParent(std::unordered_set<AbstractNode*>& p);
 
        TRITON_EXPORT void setBitvectorSize(triton::uint32 size);
 
        TRITON_EXPORT void addChild(const SharedAbstractNode& child);
 
        TRITON_EXPORT void setChild(triton::uint32 index, const SharedAbstractNode& child);
 
        TRITON_EXPORT std::string str(void) const;
 
        TRITON_EXPORT virtual void init(bool withParents=false) = 0;
    };
 
 
    class ArrayNode : public AbstractNode {
      private:
        //
        // (1) Synchronize the concrete and the symbolic
        // (2) Evaluate nodes
        std::unordered_map<triton::uint64, triton::uint8> memory;
 
        triton::uint32 indexSize;
 
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT ArrayNode(triton::uint32 indexSize, const SharedAstContext& ctxt);
        TRITON_EXPORT void init(bool withParents=false);
 
        TRITON_EXPORT void store(triton::uint64 addr, triton::uint8 value);
 
        TRITON_EXPORT triton::uint8 select(triton::uint64 addr) const;
 
        TRITON_EXPORT triton::uint8 select(const triton::uint512& addr) const;
 
        TRITON_EXPORT triton::uint8 select(const SharedAbstractNode& node) const;
 
        TRITON_EXPORT std::unordered_map<triton::uint64, triton::uint8>& getMemory(void);
 
        TRITON_EXPORT triton::uint32 getIndexSize(void) const;
    };
 
 
    class AssertNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT AssertNode(const SharedAbstractNode& expr);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BswapNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BswapNode(const SharedAbstractNode& expr);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvaddNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvaddNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvandNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvandNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvashrNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvashrNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvlshrNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvlshrNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvmulNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvmulNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvnandNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvnandNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvnegNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvnegNode(const SharedAbstractNode& expr);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvnorNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvnorNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvnotNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvnotNode(const SharedAbstractNode& expr1);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvorNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvorNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvrolNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvrolNode(const SharedAbstractNode& expr, triton::uint32 rot);
        TRITON_EXPORT BvrolNode(const SharedAbstractNode& expr, const SharedAbstractNode& rot);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvrorNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvrorNode(const SharedAbstractNode& expr, triton::uint32 rot);
        TRITON_EXPORT BvrorNode(const SharedAbstractNode& expr, const SharedAbstractNode& rot);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvsdivNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvsdivNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvsgeNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvsgeNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvsgtNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvsgtNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvshlNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvshlNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvsleNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvsleNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvsltNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvsltNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvsmodNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvsmodNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvsremNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvsremNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvsubNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvsubNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvudivNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvudivNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvugeNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvugeNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvugtNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvugtNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvuleNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvuleNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvultNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvultNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvuremNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvuremNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvxnorNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvxnorNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvxorNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvxorNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class BvNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT BvNode(const triton::uint512& value, triton::uint32 size, const SharedAstContext& ctxt);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class CompoundNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        template <typename T> CompoundNode(const T& exprs, const SharedAstContext& ctxt)
          : AbstractNode(COMPOUND_NODE, ctxt) {
          for (auto expr : exprs)
            this->addChild(expr);
        }
 
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class ConcatNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        template <typename T> ConcatNode(const T& exprs, const SharedAstContext& ctxt)
          : AbstractNode(CONCAT_NODE, ctxt) {
          for (auto expr : exprs)
            this->addChild(expr);
        }
 
        TRITON_EXPORT ConcatNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class DeclareNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT DeclareNode(const SharedAbstractNode& var);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class DistinctNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT DistinctNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class EqualNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT EqualNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class ExtractNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT ExtractNode(triton::uint32 high, triton::uint32 low, const SharedAbstractNode& expr);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class ForallNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        template <typename T> ForallNode(const T& vars, const SharedAbstractNode& body)
          : AbstractNode(FORALL_NODE, body->getContext()) {
          for (auto var : vars)
            this->addChild(var);
          this->addChild(body);
        }
 
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class IffNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT IffNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class IntegerNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      protected:
        triton::uint512 value;
 
      public:
        TRITON_EXPORT IntegerNode(const triton::uint512& value, const SharedAstContext& ctxt);
        TRITON_EXPORT void init(bool withParents=false);
        TRITON_EXPORT triton::uint512 getInteger(void);
    };
 
 
    class IteNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT IteNode(const SharedAbstractNode& ifExpr, const SharedAbstractNode& thenExpr, const SharedAbstractNode& elseExpr);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class LandNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        template <typename T> LandNode(const T& exprs, const SharedAstContext& ctxt)
          : AbstractNode(LAND_NODE, ctxt) {
          for (auto expr : exprs)
            this->addChild(expr);
        }
 
        TRITON_EXPORT LandNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class LetNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT LetNode(std::string alias, const SharedAbstractNode& expr2, const SharedAbstractNode& expr3);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class LnotNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT LnotNode(const SharedAbstractNode& expr);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class LorNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        template <typename T> LorNode(const T& exprs, const SharedAstContext& ctxt)
          : AbstractNode(LOR_NODE, ctxt) {
          for (auto expr : exprs)
            this->addChild(expr);
        }
 
        TRITON_EXPORT LorNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class LxorNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        template <typename T> LxorNode(const T& exprs, const SharedAstContext& ctxt)
          : AbstractNode(LXOR_NODE, ctxt) {
          for (auto expr : exprs)
            this->addChild(expr);
        }
 
        TRITON_EXPORT LxorNode(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class ReferenceNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      protected:
        triton::engines::symbolic::SharedSymbolicExpression expr;
 
      public:
        TRITON_EXPORT ReferenceNode(const triton::engines::symbolic::SharedSymbolicExpression& expr);
        TRITON_EXPORT void init(bool withParents=false);
        TRITON_EXPORT const triton::engines::symbolic::SharedSymbolicExpression& getSymbolicExpression(void) const;
    };
 
 
    class SelectNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT SelectNode(const SharedAbstractNode& array, triton::usize index);
        TRITON_EXPORT SelectNode(const SharedAbstractNode& array, const SharedAbstractNode& index);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class StoreNode : public AbstractNode {
      private:
        //
        // (1) Synchronize the concrete and the symbolic
        // (2) Evaluate nodes
        std::unordered_map<triton::uint64, triton::uint8> memory;
 
        triton::uint32 indexSize;
 
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT StoreNode(const SharedAbstractNode& array, triton::usize index, const SharedAbstractNode& expr);
        TRITON_EXPORT StoreNode(const SharedAbstractNode& array, const SharedAbstractNode& index, const SharedAbstractNode& expr);
        TRITON_EXPORT void init(bool withParents=false);
 
        TRITON_EXPORT triton::uint8 select(triton::uint64 addr) const;
 
        TRITON_EXPORT triton::uint8 select(const triton::uint512& addr) const;
 
        TRITON_EXPORT triton::uint8 select(const SharedAbstractNode& node) const;
 
        TRITON_EXPORT std::unordered_map<triton::uint64, triton::uint8>& getMemory(void);
 
        TRITON_EXPORT triton::uint32 getIndexSize(void) const;
    };
 
 
    class StringNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      protected:
        std::string value;
 
      public:
        TRITON_EXPORT StringNode(std::string value, const SharedAstContext& ctxt);
        TRITON_EXPORT void init(bool withParents=false);
        TRITON_EXPORT std::string getString(void);
    };
 
 
    class SxNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT SxNode(triton::uint32 sizeExt, const SharedAbstractNode& expr);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
 
    class VariableNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      protected:
        triton::engines::symbolic::SharedSymbolicVariable symVar;
 
      public:
        TRITON_EXPORT VariableNode(const triton::engines::symbolic::SharedSymbolicVariable& symVar, const SharedAstContext& ctxt);
        TRITON_EXPORT void init(bool withParents=false);
        TRITON_EXPORT const triton::engines::symbolic::SharedSymbolicVariable& getSymbolicVariable(void);
    };
 
 
    class ZxNode : public AbstractNode {
      private:
        TRITON_EXPORT void initHash(void);
 
      public:
        TRITON_EXPORT ZxNode(triton::uint32 sizeExt, const SharedAbstractNode& expr);
        TRITON_EXPORT void init(bool withParents=false);
    };
 
    triton::uint512 hash2n(triton::uint512 hash, triton::uint32 n);
 
    triton::uint512 rotl(const triton::uint512& value, triton::uint32 shift);
 
    triton::sint512 modularSignExtend(AbstractNode* node);
 
    TRITON_EXPORT std::ostream& operator<<(std::ostream& stream, AbstractNode* node);
 
    TRITON_EXPORT SharedAbstractNode newInstance(AbstractNode* node, bool unroll=false);
 
    TRITON_EXPORT SharedAbstractNode unroll(const SharedAbstractNode& node);
 
    TRITON_EXPORT std::vector<SharedAbstractNode> childrenExtraction(const SharedAbstractNode& node, bool unroll, bool revert);
 
    TRITON_EXPORT std::vector<SharedAbstractNode> parentsExtraction(const SharedAbstractNode& node, bool revert);
 
    TRITON_EXPORT std::deque<SharedAbstractNode> search(const SharedAbstractNode& node, triton::ast::ast_e match=ANY_NODE);
 
    TRITON_EXPORT SharedAbstractNode dereference(const SharedAbstractNode& node);
 
    triton::uint32 getIndexSize(const SharedAbstractNode& node);
 
    template <typename T> T inline getInteger(const SharedAbstractNode& node) {
      if (node->getType() == INTEGER_NODE) {
        return static_cast<T>(reinterpret_cast<IntegerNode*>(node.get())->getInteger());
      }
      throw triton::exceptions::Ast("triton::ast::getInteger(): You must provide an INTEGER_NODE.");
    }
 
    template <> std::string inline getInteger(const SharedAbstractNode& node) {
      if (node->getType() == INTEGER_NODE) {
        return triton::utils::toString(reinterpret_cast<triton::ast::IntegerNode*>(node.get())->getInteger());
      }
      throw triton::exceptions::Ast("triton::ast::getInteger(): You must provide an INTEGER_NODE.");
    }
 
  };
};
 
#endif /* TRITON_AST_H */