fcml_stateful_disassembler.hpp

Go to the documentation of this file.

/*
 * FCML - Free Code Manipulation Library.
 * Copyright (C) 2010-2020 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
 */

#ifndef FCML_STATEFUL_DISASSEMBLER_HPP_
#define FCML_STATEFUL_DISASSEMBLER_HPP_

#include "fcml_disassembler.hpp"
#include "fcml_renderer.hpp"

namespace fcml {

class StatefulDisassembler {
public:

    StatefulDisassembler(Disassembler &disassembler,
            DisassemblerContext &context, bool enableRendering = false) :
            _disassembler(disassembler),
            _disassemblerContext(context) {
        _renderer = enableRendering ?
                new Renderer(disassembler.getDialect()) : NULL;
        // End of line characters to be used when instructions are
        // rendered directly to the output stream.
#if defined(_WIN32)
        _endOfLine = FCML_TEXT( "\r\n" );
#else
        _endOfLine = FCML_TEXT("\n");
#endif
    }

    virtual ~StatefulDisassembler() {
        if (_renderer) {
            delete _renderer;
        }
    }

    StatefulDisassembler& operator >>(Instruction &instruction) {

        // IP has to be incremented automatically, instruction by instruction.
        DisassemblerConf &config = _disassemblerContext.getDisassemblerConf();
        config.setIncrementIp(true);
        config.setThrowExceptionOnError(true);

        // We don't care about error handling here, because it's disassembler
        // who is responsible for correctly handling it.
        _disassembler.disassemble(_disassemblerContext, _disassemblerResult);

        instruction = _disassemblerResult.getInstruction();

        return *this;

    }

    StatefulDisassembler& operator >>(fcml_cstring &instruction) {

        if (!_renderer) {
            throw IllegalStateException(FCML_TEXT("Rendering is disabled."));
        }

        // IP has to be incremented automatically, instruction by instruction.
        DisassemblerConf &config = _disassemblerContext.getDisassemblerConf();
        config.setIncrementIp(true);
        config.setThrowExceptionOnError(true);

        _disassembler.disassemble(_disassemblerContext, _disassemblerResult);

        _rendererConfig.setThrowExceptionOnError(true);
        _renderer->render(_rendererConfig, _disassemblerResult, instruction);

        return *this;

    }

    StatefulDisassembler& operator >>(fcml_costream &ostream) {

        fcml_cstring instruction;

        // Render the next instruction into a string.
        *this >> instruction;

        // Appends the instruction into an output stream.
        ostream << instruction << _endOfLine;

        return *this;

    }

    RenderConfig& getRendererConfig() {
        return _rendererConfig;
    }

    const RenderConfig& getRendererConfig() const {
        return _rendererConfig;
    }

    const fcml_cstring& getEndOfLine() const {
        return _endOfLine;
    }

    void setEndOfLine(const fcml_cstring &endOfLine) {
        _endOfLine = endOfLine;
    }

private:

    fcml_cstring _endOfLine;
    DisassemblerResult _disassemblerResult;
    Disassembler &_disassembler;
    DisassemblerContext &_disassemblerContext;
    RenderConfig _rendererConfig;
    Renderer *_renderer;

};

}

#endif /* FCML_STATEFUL_DISASSEMBLER_HPP_ */