Subversion Repositories riscv_vhdl

/*
 *  Copyright 2018 Sergey Khabarov, sergeykhbr@gmail.com
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
 
#ifndef __DEBUGGER_ATTRIBUTE_H__
#define __DEBUGGER_ATTRIBUTE_H__
 
#include <stdint.h>
#include <string.h>
#include <iattr.h>
 
namespace debugger {
 
enum KindType {
        Attr_Invalid,
        Attr_String,
        Attr_Integer,
        Attr_UInteger,
        Attr_Floating,
        Attr_List,
        Attr_Data,
        Attr_Nil,
        Attr_Dict,
        Attr_Boolean,
        Attr_Interface,
        Attr_PyObject,
};
 
class AttributePairType;
 
class AttributeType : public IAttribute {
 public:
    KindType kind_;
    unsigned size_;
    union {
        char *string;
        int64_t integer;
        bool boolean;
        double floating;
        AttributeType *list;
        AttributePairType *dict;
        uint8_t *data;
        uint8_t data_bytes[8];  // Data without allocation
        void *py_object;
        IFace *iface;
        char *uobject;
    } u_;
 
    AttributeType(const AttributeType& other) {
        size_ = 0;
        clone(&other);
    }
 
    AttributeType() {
        kind_ = Attr_Invalid;
        size_ = 0;
        u_.integer = 0;
    }
    ~AttributeType() {
        attr_free();
    }
 
    /** IAttribute */
    virtual void allocAttrName(const char *name);
    virtual void freeAttrName();
    virtual void allocAttrDescription(const char *descr);
    virtual void freeAttrDescription();
 
    void attr_free();
 
    explicit AttributeType(const char *str) {
        make_string(str);
    }
 
    explicit AttributeType(IFace *mod) {
        kind_ = Attr_Interface;
        u_.iface = mod;
    }
 
    explicit AttributeType(KindType type) {
        kind_ = type;
        size_ = 0;
        u_.integer = 0;
    }
 
    explicit AttributeType(bool val) {
        kind_ = Attr_Boolean;
        size_ = 0;
        u_.boolean = val;
    }
 
    AttributeType(KindType type, uint64_t v) {
        if (type == Attr_Integer) {
            make_int64(static_cast<int64_t>(v));
        } else if (type == Attr_UInteger) {
            make_uint64(v);
        }
    }
 
    unsigned size() const { return size_; }
 
    bool is_floating() const {
        return kind_ == Attr_Floating;
    }
 
    double to_float() const {
        return u_.floating;
    }
 
    bool is_integer() const {
        return kind_ == Attr_Integer || kind_ == Attr_UInteger;
    }
 
    bool is_int64() const {
        return kind_ == Attr_Integer;
    }
 
    int to_int() const {
        return static_cast<int>(u_.integer);
    }
 
    uint32_t to_uint32() const {
        return static_cast<uint32_t>(u_.integer);
    }
 
    int64_t to_int64() const {
        return u_.integer;
    }
 
    bool is_uint64() const {
        return kind_ == Attr_UInteger;
    }
 
    uint64_t to_uint64() const {
        return u_.integer;
    }
 
    bool is_bool() const {
        return kind_ == Attr_Boolean;
    }
 
    bool to_bool() const { return u_.boolean; }
 
    bool is_string() const {
        return kind_ == Attr_String;
    }
 
    const char * to_string() const {
        return u_.string;
    }
 
    bool is_equal(const char *v);
 
    // capitalize letters in string;
    const char * to_upper() const {
        if (kind_ != Attr_String) {
            return 0;
        }
        char *p = u_.string;
        while (*p) {
            if (p[0] >= 'a' && p[0] <= 'z') {
                p[0] = p[0] - 'a' + 'A';
            }
            p++;
        }
        return u_.string;
    }
 
    bool is_list() const {
        return kind_ == Attr_List;
    }
 
    bool is_dict() const {
        return kind_ == Attr_Dict;
    }
 
    bool is_data() const {
        return kind_ == Attr_Data;
    }
 
    bool is_iface() const {
        return kind_ == Attr_Interface;
    }
 
    IFace *to_iface() const {
        return u_.iface;
    }
 
    bool is_nil() const {
        return kind_ == Attr_Nil;
    }
 
    bool is_invalid() const {
        return kind_ == Attr_Invalid;
    }
 
 
    void clone(const AttributeType *v);
 
    void make_nil() {
        kind_ = Attr_Nil;
        size_ = 0;
        u_.integer = 0;
    }
 
    void make_iface(IFace *value) {
        kind_ = Attr_Interface;
        u_.iface = value;
    }
 
    void make_floating(double value) {
        kind_ = Attr_Floating;
        size_ = 0;
        u_.floating = value;
    }
 
    void force_to_floating() {
        kind_ = Attr_Floating;
    }
 
    void make_int64(int64_t value) {
        kind_ = Attr_Integer;
        size_ = 0;
        u_.integer = value;
    }
 
    void make_uint64(uint64_t value) {
        kind_ = Attr_UInteger;
        size_ = 0;
        u_.integer = value;
    }
 
    void make_boolean(bool value) {
        kind_ = Attr_Boolean;
        size_ = 0;
        u_.boolean = value;
    }
 
    void make_string(const char *value);
 
    void make_data(unsigned size);
 
    void make_data(unsigned size, const void *data);
 
    void realloc_data(unsigned size);
 
    void make_list(unsigned size);
 
    void add_to_list(const AttributeType *item) {
        realloc_list(size()+1);
        (*this)[size()-1] = (*item);
    }
 
    void insert_to_list(unsigned idx, const AttributeType *item);
 
    void remove_from_list(unsigned idx);
 
    void trim_list(unsigned start, unsigned end);
 
    void swap_list_item(unsigned n, unsigned m);
 
    void realloc_list(unsigned size);
 
    void make_dict();
    void realloc_dict(unsigned size);
 
    // Getter:
    double floating() const { return u_.floating; }
 
    int64_t integer() const { return u_.integer; }
 
    const char *string() const { return u_.string; }
 
    bool boolean() const { return u_.boolean; }
 
    const AttributeType *list(unsigned idx) const {
        return &u_.list[idx];
    }
    AttributeType *list(unsigned idx) {
        return &u_.list[idx];
    }
 
    /* Quicksort algorithm with 'list' attribute */
    void sort(int idx = 0);
 
    bool has_key(const char *key) const;
 
    const AttributeType *dict_key(unsigned idx) const;
    AttributeType *dict_key(unsigned idx);
 
    const AttributeType *dict_value(unsigned idx) const;
    AttributeType *dict_value(unsigned idx);
 
    const uint8_t *data() const {
        if (size_ > 8) {
            return u_.data;
        }
        return u_.data_bytes;
    }
    uint8_t *data() {
        if (size_ > 8) {
            return u_.data;
        }
        return u_.data_bytes;
    }
 
    AttributeType& operator=(const AttributeType& other);
 
    /**
     * @brief Access to the single element of the 'list' attribute:
     */
    const AttributeType& operator[](unsigned idx) const;
    /** @overload */
    AttributeType& operator[](unsigned idx);
 
    /**
     * @brief Access to the single value attribute of the 'dictionary':
     */
    const AttributeType& operator[](const char *key) const;
    /** @overload */
    AttributeType& operator[](const char *key);
 
    /**
     * @brief Access to the single byte of the 'data' attribute:
     */
    const uint8_t& operator()(unsigned idx) const;
 
    const AttributeType& to_config();
    void from_config(const char *str);
};
 
class AttributePairType {
 public:
    AttributeType key_;
    AttributeType value_;
};
 
}  // namespace debugger
 
#endif  // __DEBUGGER_ATTRIBUTE_H__