libfcml-dev 1.1.1-1 / usr / include / fcml / fcml_disassembler.hpp

/*
 * FCML - Free Code Manipulation Library.
 * Copyright (C) 2010-2015 Slawomir Wojtasiak
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

/** @file fcml_disassembler.hpp
 * C++ wrapper for the FCML disassembler.
 *
 * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved.
 * This project is released under the GNU Lesser General Public License.
 */

#ifndef FCML_DISASSEMBLER_HPP_
#define FCML_DISASSEMBLER_HPP_

#include <string.h>

#include "fcml_disassembler.h"

#include "fcml_common.hpp"
#include "fcml_errors.hpp"
#include "fcml_dialect.hpp"

namespace fcml {

/**
 *  Component can not be initialized correctly.
 *  @since 1.1.0
 */
class DisassemblingFailedException: public ErrorContainerAwareException {
public:
    DisassemblingFailedException( const fcml_cstring &msg, const ErrorContainer &errorContainer, fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR ) :
        ErrorContainerAwareException( msg, errorContainer, error ){
    }
};

/** Disassembler configuration.
 *
 * It's counterpart to the fcml_st_disassembler_conf structure.
 * @since 1.1.0
 */
class DisassemblerConf {
public:

    /**
     * Default constructor.
     * @since 1.1.0
     */
    DisassemblerConf() :
        _throwExceptionOnError(true),
        _incrementIP(true),
        _enableErrorMessages(true),
        _carryFlagConditionalSuffix(false),
        _conditionalGroup(false),
        _shortForms(false),
        _extendDispToASA(false),
        _failIfUnknownInstruction(false) {
    }

    /** @since 1.1.0 */
    bool isCarryFlagConditionalSuffix() const {
        return _carryFlagConditionalSuffix;
    }

    /** @since 1.1.0 */
    void setCarryFlagConditionalSuffix(bool carryFlagConditionalSuffix) {
        _carryFlagConditionalSuffix = carryFlagConditionalSuffix;
    }

    /** @since 1.1.0 */
    fcml_uint8_t getConditionalGroup() const {
        return _conditionalGroup;
    }

    /** @since 1.1.0 */
    void setConditionalGroup(fcml_uint8_t conditionalGroup) {
        _conditionalGroup = conditionalGroup;
    }

    /** @since 1.1.0 */
    bool isEnableErrorMessages() const {
        return _enableErrorMessages;
    }

    /** @since 1.1.0 */
    void setEnableErrorMessages(bool enableErrorMessages) {
        _enableErrorMessages = enableErrorMessages;
    }

    /** @since 1.1.0 */
    bool isExtendDispToAsa() const {
        return _extendDispToASA;
    }

    /** @since 1.1.0 */
    void setExtendDispToAsa(bool extendDispToAsa) {
        _extendDispToASA = extendDispToAsa;
    }

    /** @since 1.1.0 */
    bool isFailIfUnknownInstruction() const {
        return _failIfUnknownInstruction;
    }

    /** @since 1.1.0 */
    void setFailIfUnknownInstruction(bool failIfUnknownInstruction) {
        _failIfUnknownInstruction = failIfUnknownInstruction;
    }

    /** @since 1.1.0 */
    bool isIncrementIp() const {
        return _incrementIP;
    }

    /** @since 1.1.0 */
    void setIncrementIp(bool incrementIp) {
        _incrementIP = incrementIp;
    }

    /** @since 1.1.0 */
    bool isShortForms() const {
        return _shortForms;
    }

    /** @since 1.1.0 */
    void setShortForms(bool shortForms) {
        _shortForms = shortForms;
    }

    /**
     * Returns true if exception should be thrown when disassembling fails.
     *
     * @return True if exception is the preferred way of error handling in case of failure.
     * @since 1.1.0
     */
    bool isThrowExceptionOnError() const {
        return _throwExceptionOnError;
    }

    /**
     * Sets the way how the error handling is done.
     *
     * @param throwExceptionOnError True if exception should be thrown in case of failure.
     * @since 1.1.0
     */
    void setThrowExceptionOnError(bool throwExceptionOnError) {
        _throwExceptionOnError = throwExceptionOnError;
    }

private:
    bool _throwExceptionOnError;
    bool _incrementIP;
    bool _enableErrorMessages;
    bool _carryFlagConditionalSuffix;
    fcml_uint8_t _conditionalGroup;
    bool _shortForms;
    bool _extendDispToASA;
    bool _failIfUnknownInstruction;

};

/** Disassembler context.
 * @since 1.1.0
 */
class DisassemblerContext {
public:

    /**
     * Creates empty disassembler context.
     * @since 1.1.0
     */
    DisassemblerContext() :
        _code(NULL),
        _codeLength(0) {
    }

    /**
     * Creates disassembler context for given piece of machine code.
     *
     * @param code A buffer with the machine code.
     * @param codeLength Size of the buffer in bytes.
     * @since 1.1.0
     */
    DisassemblerContext( fcml_ptr code, fcml_usize codeLength ) :
        _code(code),
        _codeLength(codeLength) {
    }

public:

    /**
     * Gets pointer to the machine code buffer.
     *
     * @return A pointer to the machine code.
     * @since 1.1.0
     */
    fcml_ptr getCode() const {
        return _code;
    }

    /**
     * Sets a new buffer with machine code for the context.
     *
     * @param code The new code buffer.
     * @since 1.1.0
     */
    void setCode(fcml_ptr code) {
        _code = code;
    }

    /**
     * Gets length of the buffer in bytes.
     *
     * @return Size of the buffer.
     * @since 1.1.0
     */
    fcml_usize getCodeLength() const {
        return _codeLength;
    }

    /**
     * Sets length of the code buffer in bytes.
     *
     * @param codeLength Size of the code.
     * @since 1.1.0
     */
    void setCodeLength(fcml_usize codeLength) {
        _codeLength = codeLength;
    }

    /**
     * Gets a reference to the configuration object associated with the context.
     *
     * @return The disassembler configuration.
     * @since 1.1.0
     */
    const DisassemblerConf& getDisassemblerConf() const {
        return _disassemblerConf;
    }

    /**
     * Gets a reference to the configuration object associated with the context.
     *
     * @return The disassembler configuration.
     * @since 1.1.0
     */
    DisassemblerConf& getDisassemblerConf() {
        return _disassemblerConf;
    }

    /**
     * Sets a new disassembler configuration for the context.
     *
     * @param disassemblerConf The new disassembler configuration.
     * @since 1.1.0
     */
    void setDisassemblerConf(DisassemblerConf disassemblerConf) {
        _disassemblerConf = disassemblerConf;
    }

    /**
     * Gets reference to the constant entry point instance associated with the context.
     *
     * @return Reference to the constant entry point.
     * @since 1.1.0
     */
    const EntryPoint& getEntryPoint() const {
        return _entryPoint;
    }

    /**
     * Gets reference to the entry point instance associated with the context.
     *
     * @return Reference to the entry point.
     * @since 1.1.0
     */
    EntryPoint& getEntryPoint() {
        return _entryPoint;
    }
    /**
     * Copies given entry point to the instance associated with the context.
     * Deep copy is performed, so passed object not need to be maintained as
     * long as the context is used.
     *
     * @param entryPoint The entry point which is copied to the context.
     * @since 1.1.0
     */
    void setEntryPoint(const EntryPoint& entryPoint) {
        _entryPoint = entryPoint;
    }

    /**
     * Sets instruction pointer directly into the entry point.
     *
     * @param ip The new IP.
     * @since 1.1.0
     */
    void setIP( fcml_ip ip ) {
        _entryPoint.setIP(ip);
    }

    /**
     * Increments entry point by given number of bytes.
     *
     * @param ip Number of bytes the instruction pointer has to be incremented by.
     * @since 1.1.0
     */
    void incrementIP( fcml_ip ip ) {
        _entryPoint.incrementIP( ip );
    }

    /**
     * Sets processor operating mode directly into the entry point.
     *
     * @param operatingMode Processor operating mode to be set.
     * @since 1.1.0
     */
    void setOperatingMode( EntryPoint::OperatingMode operatingMode ) {
        _entryPoint.setOpMode( operatingMode );
    }

    /**
     * Sets a new address size attribute for the entry point.
     *
     * @param addressSizeAttribute The address size attribute.
     * @since 1.1.0
     */
    void setAddressSizeAttribute( fcml_usize addressSizeAttribute ) {
       _entryPoint.setAddressSizeAttribute( addressSizeAttribute );
    }

    /**
     * Sets a new operand size attribute for the entry point.
     *
     * @param operandSizeAttribute The operand size attribute.
     * @since 1.1.0
     */
    void setOperandSizeAttribute( fcml_usize operandSizeAttribute ) {
       _entryPoint.setOperandSizeAttribute( operandSizeAttribute );
    }

private:
    /** Disassembler configuration. */
    DisassemblerConf _disassemblerConf;
    /** Entry point. */
    EntryPoint _entryPoint;
    /** Code buffer. */
    fcml_ptr _code;
    /** Code length. */
    fcml_usize _codeLength;
};

/** Instruction prefix.
 * @since 1.1.0
 */
class InstructionPrefixDetails {
public:

    /** Type of the instruction prefix.
     * @since 1.1.0
     */
    enum PrefixType {
        PT_GROUP_UNKNOWN = FCML_PT_GROUP_UNKNOWN,
        PT_GROUP_1 = FCML_PT_GROUP_1,
        PT_GROUP_2 = FCML_PT_GROUP_2,
        PT_GROUP_3 = FCML_PT_GROUP_3,
        PT_GROUP_4 = FCML_PT_GROUP_4,
        PT_REX = FCML_PT_REX,
        PT_VEX = FCML_PT_VEX,
        PT_XOP = FCML_PT_XOP
    };

    /**
     * Returns true if it's a mandatory prefix.
     *
     * @return True if it's a mandatory prefix.
     * @since 1.1.0
     */
    bool isMandatoryPrefix() const {
        return _mandatoryPrefix;
    }

    /**
     * Sets mandatory prefix flag for the prefix.
     *
     * @param mandatoryPrefix Set to true in order to make the prefix mandatory one.
     * @since 1.1.0
     */
    void setMandatoryPrefix(bool mandatoryPrefix) {
        _mandatoryPrefix = mandatoryPrefix;
    }

    /**
     * Gets the prefix byte.
     *
     * @return The prefix byte.
     * @since 1.1.0
     */
    fcml_uint8_t getPrefix() const {
        return _prefix;
    }

    /**
     * Sets the prefix byte.
     *
     * @param prefix The prefix byte.
     * @since 1.1.0
     */
    void setPrefix(fcml_uint8_t prefix) {
        _prefix = prefix;
    }

    /**
     * Gets the prefix type.
     *
     * @return The prefix byte.
     * @since 1.1.0
     */
    PrefixType getPrefixType() const {
        return _prefixType;
    }

    /**
     * Sets a new prefix type.
     *
     * @param prefixType The prefix byte to be set.
     * @since 1.1.0
     */
    void setPrefixType(PrefixType prefixType) {
        _prefixType = prefixType;
    }

    /**
     * Gets the second and third bytes of the XOP/VEX prefix.
     *
     * @return A pointer to the VEX/XOP bytes.
     * @since 1.1.0
     */
    const fcml_uint8_t* getVexXopBytes() const {
        return _vexXOPBytes;
    }

    /**
     * Gets the second and third bytes of the XOP/VEX prefix.
     *
     * @return A pointer to the VEX/XOP bytes.
     * @since 1.1.0
     */
    fcml_uint8_t* getVexXopBytes() {
        return _vexXOPBytes;
    }

private:
    /** The first byte of the prefix. */
    fcml_uint8_t _prefix;
    /** Tye type of the prefix. */
    PrefixType _prefixType;
    /** True if the prefix is a mandatory one. */
    bool _mandatoryPrefix;
    /** The second and third byte of the prefix. */
    fcml_uint8_t _vexXOPBytes[2];
};

/** Prefixes details.
 * @since 1.1.0
 */
class PrefixesDetails {
public:

    /**
     * Default constructor.
     * @since 1.1.0
     */
    PrefixesDetails() :
        _prefixesCount(0),
        _prefixesBytesCount(0),
        _isBranch(false),
        _isNobranch(false),
        _isLock(false),
        _isRep(false),
        _isRepne(false),
        _isXrelease(false),
        _isXacquire(false),
        _isVex(false),
        _isXop(false),
        _isRex(false),
        _vexXopFirstByte(false),
        _r(0),
        _x(0),
        _b(0),
        _w(0),
        _l(0),
        _mmmm(0),
        _vvvv(0),
        _pp(0) {
    }

    /**
     * Gets reference to the instruction prefix at given index.
     * @param index Number of the prefix.
     * @return The instruction prefix for given index.
     * @throw IllegalArgumentException Index out of bound.
     * @since 1.1.0
     */
    const InstructionPrefixDetails& operator[](fcml_usize index) const {
        if( index >= FCML_DASM_PREFIXES_COUNT ) {
            throw IllegalArgumentException( FCML_TEXT( "Index out of bound." ) );
        }
        return _prefixes[index];
    }

    /**
     * Gets reference to the instruction prefix at given index.
     * @param index Number of the prefix.
     * @return The instruction prefix for given index.
     * @throw IllegalArgumentException Index out of bound.
     * @since 1.1.0
     */
    InstructionPrefixDetails& operator[](fcml_usize index) {
        if( index >= FCML_DASM_PREFIXES_COUNT ) {
            throw IllegalArgumentException( FCML_TEXT( "Index out of bound." ) );
        }
        return _prefixes[index];
    }

    /**
     * Gets b flag.
     *
     * @return The B flag.
     * @since 1.1.0
     */
    fcml_uint8_t getB() const {
        return _b;
    }

    /**
     * Sets B flag.
     *
     * @param b The B flag.
     * @since 1.1.0
     */
    void setB(fcml_uint8_t b) {
        _b = b;
    }

    /**
     * Gets true if branch prefix is available.
     *
     * @return True if branch prefix is available.
     * @since 1.1.0
     */
    bool isBranch() const {
        return _isBranch;
    }

    /**
     * Sets branch prefix availability.
     *
     * @param isBranch True if branch prefix is available.
     * @since 1.1.0
     */
    void setBranch(bool isBranch) {
        _isBranch = isBranch;
    }

    /**
     * Gets true if lock prefix is available.
     *
     * @return True if lock prefix is available.
     * @since 1.1.0
     */
    bool isLock() const {
        return _isLock;
    }

    /**
     * Sets lock prefix availability.
     *
     * @param isLock True if lock prefix is available.
     * @since 1.1.0
     */
    void setLock(bool isLock) {
        _isLock = isLock;
    }

    /**
     * Gets true if no-branch prefix is available.
     *
     * @return True if no-branch prefix is available.
     * @since 1.1.0
     */
    bool isNobranch() const {
        return _isNobranch;
    }

    /**
     * Sets no-branch prefix availability.
     *
     * @param isNobranch True if no-branch prefix is available.
     * @since 1.1.0
     */
    void setNobranch(bool isNobranch) {
        _isNobranch = isNobranch;
    }

    /**
     * Gets true if Rep prefix is available.
     *
     * @return True if Rep prefix is available.
     * @since 1.1.0
     */
    bool isRep() const {
        return _isRep;
    }

    /**
     * Sets Rep prefix availability.
     *
     * @param isRep True if Rep prefix is available.
     * @since 1.1.0
     */
    void setRep(bool isRep) {
        _isRep = isRep;
    }

    /**
     * Gets true if Repne prefix is available.
     *
     * @return True if Repne prefix is available.
     * @since 1.1.0
     */
    bool isRepne() const {
        return _isRepne;
    }

    /**
     * Sets Repne prefix availability.
     *
     * @param isRepne True if branch prefix is available.
     * @since 1.1.0
     */
    void setRepne(bool isRepne) {
        _isRepne = isRepne;
    }

    /**
     * Gets true if Rex prefix is available.
     *
     * @return True if Rex prefix is available.
     * @since 1.1.0
     */
    bool isRex() const {
        return _isRex;
    }

    /**
     * Sets REX prefix availability.
     *
     * @param isRex True if REX prefix is available.
     * @since 1.1.0
     */
    void setRex(bool isRex) {
        _isRex = isRex;
    }

    /**
     * Gets true if Vex prefix is available.
     *
     * @return True if Vex prefix is available.
     * @since 1.1.0
     */
    bool isVex() const {
        return _isVex;
    }

    /**
     * Sets VEX prefix availability.
     *
     * @param isVex True if VEX prefix is available.
     * @since 1.1.0
     */
    void setVex(bool isVex) {
        _isVex = isVex;
    }

    /**
     * Gets true if xacquire prefix is available.
     *
     * @return True if xacquire prefix is available.
     * @since 1.1.0
     */
    bool isXacquire() const {
        return _isXacquire;
    }

    /**
     * Sets xacquire prefix availability.
     *
     * @param isXacquire True if xacquire prefix is available.
     * @since 1.1.0
     */
    void setXacquire(bool isXacquire) {
        _isXacquire = isXacquire;
    }

    /**
     * Gets true if Xop prefix is available.
     *
     * @return True if Xop prefix is available.
     * @since 1.1.0
     */
    bool isXop() const {
        return _isXop;
    }

    /**
     * Sets Xop prefix availability.
     *
     * @param isXop True if XOP prefix is available.
     * @since 1.1.0
     */
    void setXop(bool isXop) {
        _isXop = isXop;
    }

    /**
     * Gets true if xrelease prefix is available.
     *
     * @return True if xrelease prefix is available.
     * @since 1.1.0
     */
    bool isXrelease() const {
        return _isXrelease;
    }

    /**
     * Sets xrelease prefix availability.
     *
     * @param isXrelease True if xrelease prefix is available.
     * @since 1.1.0
     */
    void setXrelease(bool isXrelease) {
        _isXrelease = isXrelease;
    }

    /**
     * Gets L flag.
     *
     * @return The L flag.
     * @since 1.1.0
     */
    fcml_uint8_t getL() const {
        return _l;
    }

    /**
     * Sets L flag.
     *
     * @param l The L flag.
     * @since 1.1.0
     */
    void setL(fcml_uint8_t l) {
        _l = l;
    }

    /**
     * Gets MMMM field.
     *
     * @return MMMM field.
     * @since 1.1.0
     */
    fcml_uint8_t getMmmm() const {
        return _mmmm;
    }

    /**
     * Sets MMMM field.
     *
     * @param mmmm MMMM field.
     * @since 1.1.0
     */
    void setMmmm(fcml_uint8_t mmmm) {
        _mmmm = mmmm;
    }

    /**
     * Gets PP field.
     *
     * @return The PP field.
     * @since 1.1.0
     */
    fcml_uint8_t getPp() const {
        return _pp;
    }

    /**
     * Sets PP field.
     *
     * @param pp PP field.
     * @since 1.1.0
     */
    void setPp(fcml_uint8_t pp) {
        _pp = pp;
    }

    /**
     * Gets a reference to the prefix of the given index.
     *
     * @param index Index for the prefix.
     * @return The prefix at given index.
     * @throw BadArgumentException Array index out of bound.
     * @since 1.1.0
     */
    const InstructionPrefixDetails& getPrefixes( fcml_usize index ) const {
        if( index > FCML_DASM_PREFIXES_COUNT ) {
            throw BadArgumentException(FCML_TEXT("Array index out of bound."), FCML_CEH_GEC_VALUE_OUT_OF_RANGE);
        }
        return _prefixes[index];
    }

    /**
     * Gets a reference to the prefix of the given index.
     *
     * @param index Index for the prefix.
     * @return The prefix at given index.
     * @throw BadArgumentException Array index out of bound.
     * @since 1.1.0
     */
    InstructionPrefixDetails& getPrefixes( fcml_usize index ) {
        if( index > FCML_DASM_PREFIXES_COUNT ) {
            throw BadArgumentException(FCML_TEXT("Array index out of bound."), FCML_CEH_GEC_VALUE_OUT_OF_RANGE);
        }
        return _prefixes[index];
    }

    /**
     * Gets number of bytes interpreted to be prefixes.
     *
     * @return Number of prefixes bytes.
     * @since 1.1.0
     */
    fcml_int getPrefixesBytesCount() const {
        return _prefixesBytesCount;
    }

    /**
     * Sets number of prefixes bytes available for the instruction.
     *
     * @param prefixesBytesCount Number of the prefixes bytes.
     * @since 1.1.0
     */
    void setPrefixesBytesCount(fcml_int prefixesBytesCount) {
        _prefixesBytesCount = prefixesBytesCount;
    }

    /**
     * Gets number of prefixes available for the instruction.
     *
     * @return Number of the prefixes for the instruction.
     * @since 1.1.0
     */
    fcml_int getPrefixesCount() const {
        return _prefixesCount;
    }

    /**
     * Sets number of prefixes available for the instruction.
     *
     * @param prefixesCount Number of the available prefixes.
     * @since 1.1.0
     */
    void setPrefixesCount(fcml_int prefixesCount) {
        _prefixesCount = prefixesCount;
    }

    /**
     * Gets R flag.
     *
     * @return The R flag.
     * @since 1.1.0
     */
    fcml_uint8_t getR() const {
        return _r;
    }

    /**
     * Sets R flag.
     *
     * @param r The R flag.
     * @since 1.1.0
     */
    void setR(fcml_uint8_t r) {
        _r = r;
    }

    /**
     * Gets the first byte of the VEX/XOP prefix.
     *
     * @return The first byte of the VEX/XOP prefix.
     * @since 1.1.0
     */
    fcml_uint8_t getVexXopFirstByte() const {
        return _vexXopFirstByte;
    }

    /**
     * Sets a first byte of the XOP/VEX prefix.
     *
     * @param vexXopFirstByte The first XOP/VEX prefix byte.
     * @since 1.1.0
     */
    void setVexXopFirstByte(fcml_uint8_t vexXopFirstByte) {
        _vexXopFirstByte = vexXopFirstByte;
    }

    /**
     * Gets VVVV field of the XOP/VEX prefix.
     *
     * @return VVVV field of the XOP/VEX prefix.
     * @since 1.1.0
     */
    fcml_uint8_t getVvvv() const {
        return _vvvv;
    }

    /**
     * Sets VVVV field of the XOP/VEX prefix.
     *
     * @param vvvv The VVVV field.
     * @since 1.1.0
     */
    void setVvvv(fcml_uint8_t vvvv) {
        _vvvv = vvvv;
    }

    /**
     * Gets W flag.
     *
     * @return The W flag.
     * @since 1.1.0
     */
    fcml_uint8_t getW() const {
        return _w;
    }

    /**
     * Sets W flag.
     *
     * @param w The W flag.
     * @since 1.1.0
     */
    void setW(fcml_uint8_t w) {
        _w = w;
    }

    /**
     * Gets X flag.
     *
     * @return The X flag.
     * @since 1.1.0
     */
    fcml_uint8_t getX() const {
        return _x;
    }

    /**
     * Sets X flag.
     *
     * @param x The X flag.
     * @since 1.1.0
     */
    void setX(fcml_uint8_t x) {
        _x = x;
    }

private:
    /** Array with decoded prefixes. */
    InstructionPrefixDetails _prefixes[FCML_DASM_PREFIXES_COUNT];
    /** Number of decoded prefixes. */
    fcml_int _prefixesCount;
    /** Number of bytes used by all decoded prefixes. */
    fcml_int _prefixesBytesCount;
    /** FCML_TRUE if branch prefix exists. */
    bool _isBranch;
    /** FCML_TRUE if nobranch prefix exists. */
    bool _isNobranch;
    /** FCML_TRUE if lock explicit prefix exists. */
    bool _isLock;
    /** FCML_TRUE if rep explicit prefix exists. */
    bool _isRep;
    /** FCML_TRUE if repne explicit prefix exists. */
    bool _isRepne;
    /** FCML_TRUE if xrelease explicit prefix exists. */
    bool _isXrelease;
    /** FCML_TRUE if xacquire explicit prefix exists. */
    bool _isXacquire;
    /** FCML_TRUE if VEX prefix exists. */
    bool _isVex;
    /** FCML_TRUE if XOP prefix exists. */
    bool _isXop;
    /** FCML_TRUE if REX prefix exists. */
    bool _isRex;
    /** Various fields encoded inside decoded prefixes.*/
    fcml_uint8_t _vexXopFirstByte;
    /** R field of REX,XOP or VEX prefix. */
    fcml_uint8_t _r;
    /** X field of REX,XOP or VEX prefix. */
    fcml_uint8_t _x;
    /** B field of REX,XOP or VEX prefix. */
    fcml_uint8_t _b;
    /** W field of REX,XOP or VEX prefix. */
    fcml_uint8_t _w;
    /** L field of XOP or VEX prefix. */
    fcml_uint8_t _l;
    /** m-mmmm field of XOP or VEX prefix. */
    fcml_uint8_t _mmmm;
    /** vvvv field of XOP or VEX prefix. */
    fcml_uint8_t _vvvv;
    /** pp field of XOP or VEX prefix. */
    fcml_uint8_t _pp;
};

/** Operand details.
 * @since 1.1.0
 */
class OperandDetails {
public:

    /** @since 1.1.0 */
    enum AccessMode {
        /** Undefined mode. */
        AM_ACCESS_MODE_UNDEFINED = FCML_AM_ACCESS_MODE_UNDEFINED,
        /** Operand is read by instruction. */
        AM_READ = FCML_AM_READ,
        /** Operand is set by instruction */
        AM_WRITE = FCML_AM_WRITE,
        /** Operand is read but can be also set. */
        AM_READ_WRITE = AM_READ | AM_WRITE
    };

    /**
     * Creates default operand details with an undefined access mode.
     * @since 1.1.0
     */
    OperandDetails() :
        _accessMode( AM_ACCESS_MODE_UNDEFINED ) {
    }

    /**
     * Creates operand details for given access mode.
     *
     * @param accessMode Access mode.
     * @since 1.1.0
     */
    OperandDetails( AccessMode accessMode ) :
        _accessMode( accessMode ) {
    }

    /**
     * Gets access mode for the operand.
     *
     * @return Access mode.
     * @since 1.1.0
     */
    AccessMode getAccessMode() const {
        return _accessMode;
    }

    /**
     * Sets an access mode for the operand.
     *
     * @param accessMode The access mode for the operand.
     * @since 1.1.0
     */
    void setAccessMode(AccessMode accessMode) {
        _accessMode = accessMode;
    }

private:
    /** Operan's access mode. */
    AccessMode _accessMode;
};

/** ModRM details.
 * @since 1.1.0
 */
class DecodedModRMDetails {
public:

    /**
     * Creates an empty ModR/M details.
     * @since 1.1.0
     */
    DecodedModRMDetails() :
        _modRM(0),
        _sib(0),
        _isRip(false) {
    }

    /**
     * Gets true if RIP byte is available.
     *
     * @return True if RIP byte is available.
     * @since 1.1.0
     */
    bool isRip() const {
        return _isRip;
    }

    /**
     * Sets RIP byte availability.
     *
     * @param isRip True if RIP byte is available.
     * @since 1.1.0
     */
    void setRip( bool isRip ) {
        _isRip = isRip;
    }

    /**
     * Gets ModR/M nullable byte.
     *
     * @return ModR/M nullable byte.
     * @since 1.1.0
     */
    const Nullable<fcml_uint8_t>& getModRM() const {
        return _modRM;
    }

    /**
     * Gets ModR/M nullable byte.
     *
     * @return ModR/M nullable byte.
     * @since 1.1.0
     */
    Nullable<fcml_uint8_t>& getModRM() {
        return _modRM;
    }

    /**
     * Sets ModR/M nullable byte.
     *
     * @param modRM ModR/M nullable byte.
     * @since 1.1.0
     */
    void setModRM( const Nullable<fcml_uint8_t> &modRM ) {
        _modRM = modRM;
    }

    /**
     * Gets SIB nullable byte.
     *
     * @return SIB nullable byte.
     * @since 1.1.0
     */
    const Nullable<fcml_uint8_t>& getSib() const {
        return _sib;
    }

    /**
     * Gets SIB nullable byte.
     *
     * @return SIB nullable byte.
     * @since 1.1.0
     */
    Nullable<fcml_uint8_t>& getSib() {
        return _sib;
    }

    /**
     * Sets SIB nullable byte.
     *
     * @param sib The SIB nullable byte.
     * @since 1.1.0
     */
    void setSib( const Nullable<fcml_uint8_t> &sib ) {
        _sib = sib;
    }

private:
    /** ModR/M byte if exists.*/
    Nullable<fcml_uint8_t> _modRM;
    /** SIB byte if exists.*/
    Nullable<fcml_uint8_t> _sib;
    /** True if RIP encoding is used by decoded instruction. This flag is used only in 64 bit mode. */
    bool _isRip;
};

/** Additional details about an instruction.
 * @since 1.1.0
 */
class InstructionDetails {
public:

    /**
     * Gets address mode/instruction form. This information is used
     * internally and is rather useless in day to day usage, but if
     * you are interested in it do not hesitate to take a look at
     * the manual.
     *
     * @return Instruction form.
     * @since 1.1.0
     */
    fcml_uint16_t getAddrMode() const {
        return _addrMode;
    }

    /**
     * Sets instruction form.
     *
     * @param addrMode Addressing mode.
     * @since 1.1.0
     */
    void setAddrMode(fcml_uint16_t addrMode) {
        _addrMode = addrMode;
    }

    /**
     * Gets instruction code. See fcml_en_instruction for more details.
     *
     * @return Instruction code.
     * @since 1.1.0
     */
    fcml_en_instruction getInstruction() const {
        return _instruction;
    }

    /**
     * Gets a new instruction code for the instruction.
     *
     * @param instruction The new instruction code.
     * @since 1.1.0
     */
    void setInstruction(fcml_en_instruction instruction) {
        _instruction = instruction;
    }

    /**
     * Gets a pointer to the instruction code. See fcml_en_instruction for more details.
     *
     * @return The pointer to the instruction code.
     * @since 1.1.0
     */
    const fcml_uint8_t* getInstructionCode() const {
        return _instructionCode;
    }

    /**
     * Gets a pointer to the instruction code. See fcml_en_instruction for more details.
     *
     * @return The pointer to the instruction code.
     * @since 1.1.0
     */
    fcml_uint8_t* getInstructionCode() {
        return _instructionCode;
    }

    /**
     * Gets instruction group. See fcml_instructions.h for all available groups.
     *
     * @return The instruction group.
     * @since 1.1.0
     */
    fcml_uint64_t getInstructionGroup() const {
        return _instructionGroup;
    }

    /**
     * Sets an instruction group. See fcml_instructions.h for all available groups.
     *
     * @param instructionGroup The instruction group.
     * @since 1.1.0
     */
    void setInstructionGroup(fcml_uint64_t instructionGroup) {
        _instructionGroup = instructionGroup;
    }

    /**
     * Instruction size in bytes.
     *
     * @return Size of the instruction in bytes.
     * @since 1.1.0
     */
    fcml_usize getInstructionSize() const {
        return _instructionSize;
    }

    /**
     * Sets the instruction size in bytes.
     *
     * @param instructionSize The instruction size.
     * @since 1.1.0
     */
    void setInstructionSize(fcml_usize instructionSize) {
        _instructionSize = instructionSize;
    }

    /**
     * Gets true if it's a shortcut instruction.
     *
     * @return True if it's a shortcut instruction.
     * @since 1.1.0
     */
    bool isShortcut() const {
        return _isShortcut;
    }

    /**
     * Marks the instruction as a shortcut.
     *
     * @param isShortcut True if it's a shortcut instruction.
     * @since 1.1.0
     */
    void setShortcut(bool isShortcut) {
        _isShortcut = isShortcut;
    }

    /**
     * Gets ModR/M instruction details.
     *
     * @return ModR/M details.
     * @since 1.1.0
     */
    const DecodedModRMDetails& getModRmDetails() const {
        return _modRMDetails;
    }

    /**
     * Gets ModR/M instruction details.
     *
     * @return ModR/M details.
     * @since 1.1.0
     */
    DecodedModRMDetails& getModRmDetails() {
        return _modRMDetails;
    }

    /**
     * Sets a new instruction details for the instruction.
     *
     * @param modRmDetails The new instruction details.
     * @since 1.1.0
     */
    void setModRmDetails(const DecodedModRMDetails& modRmDetails) {
        _modRMDetails = modRmDetails;
    }

    /**
     * Gets opcode field 'S'.
     *
     * @return 'S' opcode field.
     * @since 1.1.0
     */
    bool isOpcodeFieldSBit() const {
        return _opcodeFieldSBit;
    }

    /**
     * Sets 'S' field of the opcode byte.
     *
     * @param opcodeFieldSBit 'S' opcode byte field.
     * @since 1.1.0
     */
    void setOpcodeFieldSBit(bool opcodeFieldSBit) {
        _opcodeFieldSBit = opcodeFieldSBit;
    }

    /**
     * Gets opcode field 'W'.
     *
     * @return 'W' opcode field.
     * @since 1.1.0
     */
    bool isOpcodeFieldWBit() const {
        return _opcodeFieldWBit;
    }

    /**
     * Sets 'W' field of the opcode byte.
     *
     * @param opcodeFieldWBit 'W' opcode byte field.
     * @since 1.1.0
     */
    void setOpcodeFieldWBit(bool opcodeFieldWBit) {
        _opcodeFieldWBit = opcodeFieldWBit;
    }

    /**
     * Gets the operand details for given index.
     *
     * @param index Index of the instruction details.
     * @return The operand details for the given index.
     * @throw BadArgumentException Array index out of bound.
     * @since 1.1.0
     */
    const OperandDetails& getOperandDetails( fcml_usize index ) const {
        if( index > FCML_OPERANDS_COUNT ) {
            throw BadArgumentException(FCML_TEXT("Array index out of bound."), FCML_CEH_GEC_VALUE_OUT_OF_RANGE);
        }
        return _operandDetails[index];
    }

    /**
     * Gets the operand details for given index.
     *
     * @param index Index of the instruction details.
     * @return The operand details for the given index.
     * @throw BadArgumentException Array index out of bound.
     * @since 1.1.0
     */
    OperandDetails& getOperandDetails( fcml_usize index ) {
        if( index > FCML_OPERANDS_COUNT ) {
            throw BadArgumentException(FCML_TEXT("Array index out of bound."), FCML_CEH_GEC_VALUE_OUT_OF_RANGE);
        }
        return _operandDetails[index];
    }

    /**
     * Gets instruction prefixes details.
     *
     * @return The instruction prefix details.
     * @since 1.1.0
     */
    const PrefixesDetails& getPrefixesDetails() const {
        return _prefixesDetails;
    }

    /**
     * Gets instruction prefixes details.
     *
     * @return The instruction prefix details.
     * @since 1.1.0
     */
    PrefixesDetails& getPrefixesDetails() {
        return _prefixesDetails;
    }

    /**
     * Sets a new instruction prefixes details.
     *
     * @param prefixesDetails The new prefixes details.
     * @since 1.1.0
     */
    void setPrefixesDetails(const PrefixesDetails& prefixesDetails) {
        _prefixesDetails = prefixesDetails;
    }

    /**
     * Gets pseudo operation code.
     *
     * @return The pseudo operation associated with the instruction.
     * @since 1.1.0
     */
    fcml_en_pseudo_operations getPseudoOp() const {
        return _pseudoOp;
    }

    /**
     * Sets pseudo operation for the instruction.
     *
     * @param pseudoOp The pseudo operation.
     * @since 1.1.0
     */
    void setPseudoOp(fcml_en_pseudo_operations pseudoOp) {
        _pseudoOp = pseudoOp;
    }

    /**
     * Gets true is it's a pseudo operation.
     *
     * @return True if the instruction is a pseudo operation.
     * @since 1.1.0
     */
    bool isPseudoOp() const {
        return _isPseudoOp;
    }

    /**
     * Sets pseudo operation flag.
     *
     * @param isPseudoOp True if the instruction is a pseudo operation.
     * @since 1.1.0
     */
    void setIsPseudoOp(bool isPseudoOp) {
        _isPseudoOp = isPseudoOp;
    }

private:

    /**
     * True if this is a shortcut.
     * A good example of such instruction is 'cmpsb' as opposed to 'cmps byte ptr [si],byte ptr [di]'.
     * It is very important to take this information into consideration when instruction
     * models are analyzed because there is no operands in the GIM for shortcuts.
     */
    bool _isShortcut;
    /**
     * True if given instruction is a short form of pseudo-ops instructions. See 'vcmpunordsd' for instance.
     */
    bool _isPseudoOp;
    /**
     *  Code of the disassembled instruction.
     */
    fcml_uint8_t _instructionCode[FCML_INSTRUCTION_SIZE];
    /**
     *  Instruction size in bytes.
     */
    fcml_usize _instructionSize;
    /**
     *  Some additional information about decoded instruction prefixes.
     */
    PrefixesDetails _prefixesDetails;
    /**
     * All disassembler specific information about operands going there.
     */
    OperandDetails _operandDetails[FCML_OPERANDS_COUNT];
    /**
     * Details about decoded ModR/M and SIB bytes.
     */
    DecodedModRMDetails _modRMDetails;
    /** Opcode field 's'.
     * This is set only for informational purpose only and you should not use it for any critical functionality.
     */
    bool _opcodeFieldSBit;
    /** Opcode field 'w'.
     * This is set only for informational purpose only and you should not use it for any critical functionality.
     */
    bool _opcodeFieldWBit;
    /**
     * Instruction code/number. @see fcml_instructions.h header file.
     */
    fcml_en_instruction _instruction;
    /**
     * Pseudo operation code.
     */
    fcml_en_pseudo_operations _pseudoOp;
    /**
     *  Code of the instruction form/addressing mode of the instruction above.
     */
    fcml_uint16_t _addrMode;
    /**
     * Instruction group.
     */
    fcml_uint64_t _instructionGroup;

};

/** Disassembler result.
 *
 * It's a counterpart to the fcml_st_disassembler_result structure.
 * @since 1.1.0
 */
class DisassemblerResult {

public:

    /**
     * Gets errors container with errors related to the failed disassembling process.
     *
     * @return The error container.
     * @since 1.1.0
     */
    const ErrorContainer& getErrorContainer() const {
        return _errorContainer;
    }

    /**
     * Gets errors container with errors related to the failed disassembling process.
     *
     * @return The error container.
     * @since 1.1.0
     */
    const Instruction& getInstruction() const {
        return _instruction;
    }

    /**
     * Gets instruction details associated with the instruction.
     *
     * @return The instruction details.
     * @since 1.1.0
     */
    const InstructionDetails& getInstructionDetails() const {
        return _instructionDetails;
    }

    /**
     * Cleans the disassembling result.
     * @since 1.1.0
     */
    void clean() {
        _errorContainer.clean();
        _instructionDetails = InstructionDetails();
        _instruction = Instruction();
    }

protected:

    friend class Disassembler;
    friend class DisassemblerTypeConverter;

    /**
     * Gets mutable instruction details.
     * @return Instruction details.
     * @since 1.1.0
     */
    InstructionDetails& getInstructionDetails() {
        return _instructionDetails;
    }

    /**
     * Sets new instruction details for the disassembler.
     * @param instructionDetails The instruction details.
     * @since 1.1.0
     */
    void setInstructionDetails(const InstructionDetails& instructionDetails) {
        _instructionDetails = instructionDetails;
    }

    /**
     * Gets mutable instruction.
     * @return The mutable instruction.
     * @since 1.1.0
     */
    Instruction& getInstructionInternal() {
        return _instruction;
    }

    /**
     * Sets a new instruction for the result.
     * @param instruction The instruction to be copied to the result.
     * @since 1.1.0
     */
    void setInstruction(const Instruction& instruction) {
        _instruction = instruction;
    }

    /**
     * Sets error container.
     * @param errorContainer The error container.
     * @since 1.1.0
     */
    void setErrorContainer(const ErrorContainer& errorContainer) {
        _errorContainer = errorContainer;
    }

private:

    /** Errors container */
    ErrorContainer _errorContainer;
    /** Instruction details. */
    InstructionDetails _instructionDetails;
    /** The disassembled instruction. */
    Instruction _instruction;

};

/**
 * Converts objects to their structures counterparts.
 * @since 1.1.0
 * @remarks Internal API, not intended to be used outside.
 */
class DisassemblerTypeConverter {

protected:

    friend class Disassembler;
    friend class Renderer;

    static void convert( const DisassemblerContext &src, fcml_st_disassembler_context &dest ) {
        dest.code = src.getCode();
        dest.code_length = src.getCodeLength();
        TypeConverter::convert( src.getEntryPoint(), dest.entry_point );
        convert( src.getDisassemblerConf(), dest.configuration );
    }

    static void convert( const DisassemblerConf &src, fcml_st_disassembler_conf &dest ) {
        dest.conditional_group = src.getConditionalGroup();
        dest.carry_flag_conditional_suffix = src.isCarryFlagConditionalSuffix();
        dest.enable_error_messages = src.isEnableErrorMessages();
        dest.extend_disp_to_asa = src.isExtendDispToAsa();
        dest.fail_if_unknown_instruction = src.isFailIfUnknownInstruction();
        dest.increment_ip = src.isIncrementIp();
        dest.short_forms = src.isShortForms();
    }

    static void convert( const fcml_st_decoded_modrm_details &src, DecodedModRMDetails &dest ) {
        dest.setRip( FCML_TO_CPP_BOOL( src.is_rip ) );
        Nullable<fcml_uint8_t> modRM;
        modRM.setNotNull( FCML_TO_CPP_BOOL( src.is_modrm ) );
        modRM.setValue( src.modrm );
        Nullable<fcml_uint8_t> &sib = dest.getSib();
        sib.setNotNull( FCML_TO_CPP_BOOL( src.sib.is_not_null ) );
        sib.setValue( src.sib.value );
    }

    static void convert( const DecodedModRMDetails &src, fcml_st_decoded_modrm_details &dest ) {
        dest.is_modrm = src.getModRM().isNotNull();
        dest.is_rip = src.isRip();
        dest.modrm = src.getModRM().getValue();
        fcml_nuint8_t &sib = dest.sib;
        sib.is_not_null = src.getSib().isNotNull();
        sib.value = src.getSib().getValue();
    }

    static void convert( const fcml_st_operand_details &src, OperandDetails &dest ) {
        dest.setAccessMode( static_cast<OperandDetails::AccessMode>( src.access_mode ) );
    }

    static void convert( const OperandDetails &src, fcml_st_operand_details &dest ) {
        dest.access_mode = static_cast<fcml_en_access_mode>( src.getAccessMode() );
    }

    static void convert( const fcml_st_instruction_prefix &src, InstructionPrefixDetails &dest ) {
        dest.setMandatoryPrefix( FCML_TO_CPP_BOOL( src.mandatory_prefix ) );
        dest.setPrefix( src.prefix );
        dest.setPrefixType( dest.getPrefixType() );
        ::memcpy( dest.getVexXopBytes(), src.vex_xop_bytes, 2 );
    }

    static void convert( const InstructionPrefixDetails &src, fcml_st_instruction_prefix &dest ) {
        dest.mandatory_prefix = src.isMandatoryPrefix();
        dest.prefix = src.getPrefix();
        dest.prefix_type = static_cast<fcml_en_prefix_types>( src.getPrefixType() );
        ::memcpy( dest.vex_xop_bytes, src.getVexXopBytes(), 2 );
    }

    static void convert( const fcml_st_prefixes_details src, PrefixesDetails &dest ) {
        for( int i = 0; i < FCML_DASM_PREFIXES_COUNT; i++ ) {
            convert( src.prefixes[i], dest.getPrefixes( i ) );
        }
        dest.setPrefixesCount( src.prefixes_count );
        dest.setPrefixesBytesCount( src.prefixes_bytes_count );
        dest.setBranch( FCML_TO_CPP_BOOL( src.is_branch ) );
        dest.setNobranch( FCML_TO_CPP_BOOL( src.is_nobranch ) );
        dest.setLock( FCML_TO_CPP_BOOL( src.is_lock ) );
        dest.setRep( FCML_TO_CPP_BOOL( src.is_rep ) );
        dest.setRepne( FCML_TO_CPP_BOOL( src.is_repne ) );
        dest.setXrelease( FCML_TO_CPP_BOOL( src.is_xrelease ) );
        dest.setXacquire( FCML_TO_CPP_BOOL( src.is_xacquire ) );
        dest.setVex( FCML_TO_CPP_BOOL( src.is_vex ) );
        dest.setXop( FCML_TO_CPP_BOOL( src.is_xop ) );
        dest.setRex( FCML_TO_CPP_BOOL( src.is_rex ) );
        dest.setVexXopFirstByte( src.vex_xop_first_byte );
        dest.setR( src.r );
        dest.setX( src.x );
        dest.setB( src.b );
        dest.setW( src.w );
        dest.setL( src.l );
        dest.setMmmm( src.mmmm );
        dest.setVvvv( src.vvvv );
        dest.setPp( src.pp );
    }

    static void convert( const PrefixesDetails src, fcml_st_prefixes_details &dest ) {
        for( int i = 0; i < FCML_DASM_PREFIXES_COUNT; i++ ) {
            convert( src.getPrefixes(i), dest.prefixes[i] );
        }
        dest.prefixes_count  = src.getPrefixesCount();
        dest.prefixes_bytes_count  = src.getPrefixesBytesCount();
        dest.is_branch  = src.isBranch();
        dest.is_nobranch  = src.isNobranch();
        dest.is_lock  = src.isLock();
        dest.is_rep  = src.isRep();
        dest.is_repne  = src.isRepne();
        dest.is_xrelease  = src.isXrelease();
        dest.is_xacquire  = src.isXacquire();
        dest.is_vex  = src.isVex();
        dest.is_xop  = src.isXop();
        dest.is_rex  = src.isRex();
        dest.vex_xop_first_byte  = src.getVexXopFirstByte();
        dest.r  = src.getR();
        dest.x  = src.getX();
        dest.b  = src.getB();
        dest.w  = src.getW();
        dest.l  = src.getL();
        dest.mmmm  = src.getMmmm();
        dest.vvvv  = src.getVvvv();
        dest.pp  = src.getPp();
    }

    static void convert( const fcml_st_instruction_details &src, InstructionDetails &dest ) {
        dest.setAddrMode( src.addr_mode );
        dest.setInstruction( src.instruction );
        dest.setInstructionGroup( src.instruction_group );
        dest.setInstructionSize( src.instruction_size );
        dest.setOpcodeFieldSBit( FCML_TO_CPP_BOOL( src.opcode_field_s_bit ) );
        dest.setOpcodeFieldWBit( FCML_TO_CPP_BOOL( src.opcode_field_w_bit ) );
        dest.setIsPseudoOp( FCML_TO_CPP_BOOL( src.is_pseudo_op ) );
        dest.setPseudoOp( src.pseudo_op );
        dest.setShortcut( FCML_TO_CPP_BOOL( src.is_shortcut ) );
        convert( src.modrm_details, dest.getModRmDetails() );
        for( int i = 0; i < FCML_OPERANDS_COUNT; i++ ) {
            convert( src.operand_details[i], dest.getOperandDetails(i) );
        }
        convert( src.prefixes_details, dest.getPrefixesDetails() );
    }

    static void convert( const InstructionDetails &src, fcml_st_instruction_details &dest ) {
        dest.addr_mode = src.getAddrMode();
        dest.instruction = src.getInstruction();
        dest.instruction_group = src.getInstructionGroup();
        dest.instruction_size = src.getInstructionSize();
        dest.opcode_field_s_bit = src.isOpcodeFieldSBit();
        dest.opcode_field_w_bit = src.isOpcodeFieldWBit();
        dest.is_pseudo_op = src.isPseudoOp();
        dest.pseudo_op = src.getPseudoOp();
        dest.is_shortcut = src.isShortcut();
        convert( src.getModRmDetails(), dest.modrm_details );
        for( int i = 0; i < FCML_OPERANDS_COUNT; i++ ) {
            convert( src.getOperandDetails(i), dest.operand_details[i] );
        }
        convert( src.getPrefixesDetails(), dest.prefixes_details );
    }

    static void convert( const fcml_st_disassembler_result &src, DisassemblerResult &dest ) {
        TypeConverter::convert( src.instruction, dest.getInstructionInternal() );
        convert( src.instruction_details, dest.getInstructionDetails() );
    }

    static void convert( const DisassemblerResult &src, fcml_st_disassembler_result &dest ) {
        TypeConverter::convert( src.getInstruction(), dest.instruction );
        convert( src.getInstructionDetails(), dest.instruction_details );
    }

    static void free( fcml_st_disassembler_result &src ) {
        TypeConverter::free( src.instruction );
    }

};

/** Disassembler wrapper.
 * @since 1.1.0
 */
class Disassembler : public NonCopyable, protected DialectAware {
public:

    /**
     * Creates a disassembler instance for the given dialect.
     *
     * @param dialect The dialect for the disassembler.
     * @throw InitException Cannot initialize the disassembler.
     * @since 1.1.0
     */
    Disassembler(Dialect &dialect) :
            _dialect(dialect) {
        fcml_ceh_error error = ::fcml_fn_disassembler_init( extractDialect( dialect ), &_disassembler);
        if (error) {
            throw InitException(FCML_TEXT("Cannot initialize the disassembler."), error);
        }
    }

    /**
     * Destructor.
     * @since 1.1.0
     */
    virtual ~Disassembler() {
        if (_disassembler) {
            ::fcml_fn_disassembler_free(_disassembler);
            _disassembler = NULL;
        }
    }

public:

    /**
     * Disassembled the next instruction from the context.
     *
     * @param ctx Context describing the next instruction to disassemble.
     * @param[out] disassemblerResult Disassembler result.
     * @throw DisassemblingFailedException Disassemblation failed.
     * @return Error code.
     * @since 1.1.0
     */
    fcml_ceh_error disassemble( DisassemblerContext &ctx, DisassemblerResult &disassemblerResult ) {

        fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR;

        fcml_st_disassembler_context context;
        DisassemblerTypeConverter::convert( ctx, context );

        context.disassembler = _disassembler;

        /* Prepare assembler result. */
        fcml_st_disassembler_result disassembler_result;
        ::fcml_fn_disassembler_result_prepare( &disassembler_result );

        try {

            disassemblerResult.clean();

            error = ::fcml_fn_disassemble( &context, &disassembler_result );

            ErrorContainer errorContainer;
            ErrorTypeConverter::convert( disassembler_result.errors, errorContainer );

            disassemblerResult.setErrorContainer( errorContainer );

            if( error && ctx.getDisassemblerConf().isThrowExceptionOnError() ) {
                ::fcml_fn_disassembler_result_free( &disassembler_result );
                throw DisassemblingFailedException( FCML_TEXT("Assembling failed."), errorContainer, error );
            }

            if( !error ) {

                // Convert result.
                DisassemblerTypeConverter::convert( disassembler_result, disassemblerResult );

                ctx.getEntryPoint().setIP( context.entry_point.ip );
                ctx.setCode( context.code );
                ctx.setCodeLength( context.code_length );

            }

            ::fcml_fn_disassembler_result_free( &disassembler_result );

        } catch( std::exception &exc ) {
            // If anything failed, free assembler results.
            ::fcml_fn_disassembler_result_free( &disassembler_result );
            throw exc;
        }

        return error;
    }

    /**
     * Gets dialect associated with the disassembler.
     * @return The dialect instance associated with the disassembler.
     * @since 1.1.0
     */
    Dialect& getDialect() const {
        return _dialect;
    }

private:

    /** The dialect associated with the disassembler. */
    Dialect &_dialect;
    /** The disassembler instance. */
    fcml_st_disassembler *_disassembler;

};

}

#endif //FCML_DISASSEMBLER_HPP_