fcml_parser.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_PARSER_HPP_
#define FCML_PARSER_HPP_

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

#include "fcml_parser.h"

namespace fcml {

class ParsingFailedException: public ErrorContainerAwareException {
public:
    ParsingFailedException(const fcml_cstring msg,
            ErrorContainer &errorContainer,
            fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR) :
            ErrorContainerAwareException(msg, errorContainer, error) {
    }
};

class ParserConfig {
public:

    ParserConfig() :
            _throwExceptionOnError(true),
            _ignoreUndefinedSymbols(false),
            _disableSymbolsDeclaration(true),
            _overrideLabels(false),
            _allocSymbolTableIfNeeded(false),
            _enableErrorMessages(true) {
    }

    bool isAllocSymbolTableIfNeeded() const {
        return _allocSymbolTableIfNeeded;
    }

    void setAllocSymbolTableIfNeeded(bool allocSymbolTableIfNeeded) {
        _allocSymbolTableIfNeeded = allocSymbolTableIfNeeded;
    }

    bool isDisableSymbolsDeclaration() const {
        return _disableSymbolsDeclaration;
    }

    void setDisableSymbolsDeclaration(bool disableSymbolsDeclaration) {
        _disableSymbolsDeclaration = disableSymbolsDeclaration;
    }

    bool isEnableErrorMessages() const {
        return _enableErrorMessages;
    }

    void setEnableErrorMessages(bool enableErrorMessages) {
        _enableErrorMessages = enableErrorMessages;
    }

    bool isIgnoreUndefinedSymbols() const {
        return _ignoreUndefinedSymbols;
    }

    void setIgnoreUndefinedSymbols(bool ignoreUndefinedSymbols) {
        _ignoreUndefinedSymbols = ignoreUndefinedSymbols;
    }

    bool isOverrideLabels() const {
        return _overrideLabels;
    }

    void setOverrideLabels(bool overrideLabels) {
        _overrideLabels = overrideLabels;
    }

    bool isThrowExceptionOnError() const {
        return _throwExceptionOnError;
    }

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

private:
    bool _throwExceptionOnError;
    bool _ignoreUndefinedSymbols;
    bool _disableSymbolsDeclaration;
    bool _overrideLabels;
    bool _allocSymbolTableIfNeeded;
    bool _enableErrorMessages;
};

class ParserContext {
public:

    ParserContext(fcml_ip ip = 0) :
            _ip(ip), _symbolTable(NULL) {
    }

    ParserContext(SymbolTable *symbolTable, fcml_ip ip = 0) :
            _ip(ip), _symbolTable(symbolTable) {
    }

public:

    const ParserConfig& getConfig() const {
        return _config;
    }

    ParserConfig& getConfig() {
        return _config;
    }

    fcml_ip getIp() const {
        return _ip;
    }

    void setIp(fcml_ip ip) {
        _ip = ip;
    }

    void incrementIP(fcml_ip ip) {
        _ip += ip;
    }

    const SymbolTable* getSymbolTable() const {
        return _symbolTable;
    }

    SymbolTable* getSymbolTable() {
        return _symbolTable;
    }

    void setSymbolTable(SymbolTable *symbolTable) {
        _symbolTable = symbolTable;
    }

private:

    fcml_ip _ip;
    ParserConfig _config;
    SymbolTable *_symbolTable;

};

class ParserResult {
public:

    ParserResult() {
    }

    const ErrorContainer& getErrors() const {
        return _errors;
    }

    const Instruction& getInstruction() const {
        return _instruction;
    }

    const Nullable<Symbol>& getSymbol() const {
        return _symbol;
    }

    void clean() {
        _errors.clean();
        _symbol.setNotNull(false);
        _symbol.setValue(Symbol());
    }

protected:

    friend class Parser;

    void setErrors(const ErrorContainer &errors) {
        _errors = errors;
    }

    void setInstruction(const Instruction &instruction) {
        _instruction = instruction;
    }

    void setSymbol(const Nullable<Symbol> &symbol) {
        _symbol = symbol;
    }

private:

    ErrorContainer _errors;
    Nullable<Symbol> _symbol;
    Instruction _instruction;

};

class ParserTypeConverter {
public:

    static void convert(ParserConfig &src, fcml_st_parser_config &dest) {
        dest.alloc_symbol_table_if_needed = src.isAllocSymbolTableIfNeeded();
        dest.disable_symbols_declaration = src.isDisableSymbolsDeclaration();
        dest.enable_error_messages = src.isEnableErrorMessages();
        dest.ignore_undefined_symbols = src.isIgnoreUndefinedSymbols();
        dest.override_labels = src.isOverrideLabels();
    }

};

class Parser: protected DialectAware, protected SymbolTableAware {
public:

    Parser(const Dialect &dialect) :
            _dialect(dialect) {
    }

    fcml_ceh_error parse(ParserContext &ctx, const fcml_cstring &instruction,
            ParserResult &parserResult) {

        // Prepare parser context.
        fcml_st_parser_context context = { 0 };
        ParserTypeConverter::convert(ctx.getConfig(), context.configuration);
        context.ip = ctx.getIp();
        SymbolTable *symbolTable = ctx.getSymbolTable();
        context.symbol_table =
                (symbolTable) ? extractSymbolTable(*symbolTable) : NULL;
        context.dialect = extractDialect(_dialect);

        fcml_st_parser_result parser_result;
        ::fcml_fn_parser_result_prepare(&parser_result);

        try {

            parserResult.clean();

            // Prepare instruction.
            fcml_ceh_error error = ::fcml_fn_parse(&context,
                    instruction.c_str(), &parser_result);

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

            parserResult.setErrors(errorContainer);

            if (!error && !parser_result.instruction) {
                // Just in case, it should never happen.
                error = FCML_CEH_GEC_INTERNAL_ERROR;
            }

            if (error && ctx.getConfig().isThrowExceptionOnError()) {
                ::fcml_fn_parser_result_free(&parser_result);
                throw ParsingFailedException(
                        errorContainer.prepareErrorMessage(
                                FCML_TEXT("Parsing failed")), errorContainer,
                        error);
            }

            if (!error) {

                Instruction parsedInstruction;
                TypeConverter::convert(*(parser_result.instruction),
                        parsedInstruction);

                parserResult.setInstruction(parsedInstruction);
                parserResult.setSymbol(
                        parser_result.symbol ?
                                Symbol(parser_result.symbol->symbol,
                                        parser_result.symbol->value) :
                                Symbol());

            }

            ::fcml_fn_parser_result_free(&parser_result);

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

        return FCML_CEH_GEC_NO_ERROR;
    }

private:

    const Dialect &_dialect;

};

}

#endif /* FCML_PARSER_HPP_ */