fcml_renderer.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_RENDERER_HPP_
#define FCML_RENDERER_HPP_

#include "fcml_common.hpp"
#include "fcml_disassembler.hpp"
#include "fcml_renderer.h"

namespace fcml {

class RenderingFailedException: public BaseException {
public:
    RenderingFailedException(const fcml_cstring &msg, fcml_ceh_error error =
            FCML_CEH_GEC_NO_ERROR) :
            BaseException(msg, error) {
    }
};

class RenderConfig {
public:

    RenderConfig() :
            _throwExceptionOnError(true),
            _renderFlags(0),
            _preferedMnemonicPadding(FCML_REND_DEFAULT_MNEMONIC_PADDING),
            _preferedCodePadding(FCML_REND_DEFAULT_CODE_PADDING) {
    }

    RenderConfig(fcml_uint32_t renderFlags) :
            _throwExceptionOnError(true),
            _renderFlags(renderFlags),
            _preferedMnemonicPadding(0),
            _preferedCodePadding(0) {
    }

    fcml_uint16_t getPreferedCodePadding() const {
        return _preferedCodePadding;
    }

    void setPreferedCodePadding(fcml_uint16_t preferedCodePadding) {
        _preferedCodePadding = preferedCodePadding;
    }

    fcml_uint16_t getPreferedMnemonicPadding() const {
        return _preferedMnemonicPadding;
    }

    void setPreferedMnemonicPadding(fcml_uint16_t preferedMnemonicPadding) {
        _preferedMnemonicPadding = preferedMnemonicPadding;
    }

    fcml_uint32_t getRenderFlags() const {
        return _renderFlags;
    }

    void setRenderFlags(fcml_uint32_t renderFlags) {
        _renderFlags = renderFlags;
    }

    bool isThrowExceptionOnError() const {
        return _throwExceptionOnError;
    }

    void setThrowExceptionOnError(bool throwExceptionOnError) {
        _throwExceptionOnError = throwExceptionOnError;
    }

private:

    bool _throwExceptionOnError;
    fcml_uint32_t _renderFlags;
    fcml_uint16_t _preferedMnemonicPadding;
    fcml_uint16_t _preferedCodePadding;

};

class RenderTypeConverter {
public:

    static void convert(const RenderConfig &src, fcml_st_render_config &dest) {
        dest.prefered_code_padding = src.getPreferedCodePadding();
        dest.prefered_mnemonic_padding = src.getPreferedMnemonicPadding();
        dest.render_flags = src.getRenderFlags();
    }

};

class Renderer: protected DialectAware {
public:

    Renderer(Dialect &dialect) :
            _dialect(dialect) {
    }

    fcml_ceh_error render(const RenderConfig &renderConfig,
            DisassemblerResult &assemblerResult, fcml_cstring &result) {

        result.clear();

        fcml_st_render_config render_config;
        RenderTypeConverter::convert(renderConfig, render_config);

        fcml_st_disassembler_result disassembler_result;
        fcml_fn_disassembler_result_prepare(&disassembler_result);

        DisassemblerTypeConverter::convert(assemblerResult,
                disassembler_result);

        fcml_char buffer[FCML_REND_MAX_BUFF_LEN];

        fcml_ceh_error error = ::fcml_fn_render(extractDialect(_dialect),
                &render_config, buffer, FCML_REND_MAX_BUFF_LEN,
                &disassembler_result);

        DisassemblerTypeConverter::free(disassembler_result);

        if (error && renderConfig.isThrowExceptionOnError()) {
            throw RenderingFailedException(
                    FCML_TEXT("Can not render instruction."), error);
        }

        result = buffer;

        return error;
    }

private:

    Dialect &_dialect;

};

}

#endif /* FCML_RENDERER_HPP_ */