fcml_symbols.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_SYMBOLS_HPP_
#define FCML_SYMBOLS_HPP_

#include <new>

#include "fcml_common.hpp"
#include "fcml_symbols.h"

namespace fcml {

class Symbol {
public:

    Symbol() :
            _value(0) {
    }

    Symbol(const fcml_cstring &name, fcml_int64_t value) :
            _name(name), _value(value) {
    }

    operator fcml_uint64_t() const {
        return _value;
    }

    operator fcml_int64_t() const {
        return static_cast<fcml_int64_t>(_value);
    }

    bool isEmpty() const {
        return _name.empty();
    }

    const fcml_cstring& getName() const {
        return _name;
    }

    fcml_uint64_t getValue() const {
        return _value;
    }

    void setName(const fcml_cstring &name) {
        _name = name;
    }

    void setValue(fcml_uint64_t value) {
        _value = value;
    }

private:

    // Symbol name.
    fcml_cstring _name;
    // Symbol value.
    fcml_uint64_t _value;

};

/* Due to the performance purposes and the way symbol table is managed
 * internally, it has to be wrapped directly without doing any conversions
 * when needed.
 * @since 1.1.0
 */
class SymbolTable: public NonCopyable {
public:

    SymbolTable() :
            _symbolTable(NULL) {
        _symbolTable = ::fcml_fn_symbol_table_alloc();
        if (!_symbolTable) {
            throw InitException(
                    FCML_TEXT(
                            "Symbol table can not be initialized correctly."));
        }
    }

    virtual ~SymbolTable() {
        if (_symbolTable) {
            ::fcml_fn_symbol_table_free(_symbolTable);
            _symbolTable = NULL;
        }
    }

protected:

    friend class SymbolTableAware;

    fcml_st_symbol_table& getSymbolTable() {
        return _symbolTable;
    }

public:

    void add(const fcml_cstring &symbolName, fcml_int64_t value) {
        if (::fcml_fn_symbol_add_raw(_symbolTable, symbolName.c_str(), value)
                == FCML_CEH_GEC_OUT_OF_MEMORY) {
            throw std::bad_alloc();
        }
    }

    void remove(const fcml_cstring &symbolName) {
        const fcml_string key = symbolName.c_str();
        ::fcml_fn_symbol_remove(_symbolTable, key);
    }

    bool contains(const fcml_cstring &symbolName) const {
        return ::fcml_fn_symbol_get(_symbolTable, symbolName.c_str()) != NULL;
    }

    Symbol get(const fcml_cstring &symbolName) const {
        Symbol symbol;
        fcml_st_symbol *found_symbol = ::fcml_fn_symbol_get(_symbolTable,
                symbolName.c_str());
        if (found_symbol) {
            symbol.setName(found_symbol->symbol);
            symbol.setValue(found_symbol->value);
        }
        return symbol;
    }

private:
    fcml_st_symbol_table _symbolTable;
};

class SymbolTableAware {
public:

    fcml_st_symbol_table& extractSymbolTable(SymbolTable &symbolTable) {
        return symbolTable.getSymbolTable();
    }
};

}
#endif /* FCML_SYMBOLS_HPP_ */