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_ */