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_COMMON_ISERVICE_H__
#define __DEBUGGER_COMMON_ISERVICE_H__
 
#include <iface.h>
#include <attribute.h>
#include <api_utils.h>
#include "coreservices/imemop.h"
 
namespace debugger {
 
static const char *const IFACE_SERVICE = "IService";
 
class IService : public IFace {
 public:
    explicit IService(const char *obj_name) : IFace(IFACE_SERVICE) {
        listInterfaces_ = AttributeType(Attr_List);
        listAttributes_ = AttributeType(Attr_List);
        listPorts_ = AttributeType(Attr_List);
        registerInterface(static_cast<IService *>(this));
        registerAttribute("LogLevel", &logLevel_);
        obj_name_.make_string(obj_name);
        logLevel_.make_int64(LOG_ERROR);
    }
    virtual ~IService() {
        // @warning: NEED to unregister attribute from class destructor
        /*for (unsigned i = 0; i < listAttributes_.size(); i++) {
            IAttribute *iattr = static_cast<IAttribute *>(
                                    listAttributes_[i].to_iface());
            iattr->freeAttrName();
            iattr->freeAttrDescription();
        }*/
    }
 
    virtual void initService(const AttributeType *args) {
        if (!args || !args->is_list()) {
            return;
        }
        AttributeType *cur_attr;
        for (unsigned i = 0; i < args->size(); i++) {
            const AttributeType &item = (*args)[i];
            if (item.size() < 2 || !item[0u].is_string()) {
                continue;
            }
            cur_attr = static_cast<AttributeType *>(
                                getAttribute(item[0u].to_string()));
            if (cur_attr == NULL) {
                RISCV_error("Attribute '%s' not found", item[0u].to_string());
                continue;
            }
            (*cur_attr) = item[1];
            if (item.size() >= 3 && item[2].is_string()) {
                static_cast<IAttribute *>(cur_attr)->allocAttrDescription(
                    item[2].to_string());
            }
        }
    }
 
    virtual void postinitService() {}
    virtual void predeleteService() {}
 
    virtual void registerInterface(IFace *iface) {
        AttributeType item(iface);
        listInterfaces_.add_to_list(&item);
        if (strcmp(iface->getFaceName(), IFACE_MEMORY_OPERATION) == 0) {
            IMemoryOperation *imemop = static_cast<IMemoryOperation *>(iface);
            registerAttribute("MapList", &imemop->listMap_);
            registerAttribute("BaseAddress", &imemop->baseAddress_);
            registerAttribute("Length", &imemop->length_);
            registerAttribute("Priority", &imemop->priority_);
        }
    }
    virtual void registerPortInterface(const char *portname, IFace *iface) {
        AttributeType item;
        item.make_list(2);
        item[0u].make_string(portname);
        item[1].make_iface(iface);
        listPorts_.add_to_list(&item);
    }
 
    virtual void unregisterInterface(IFace *iface) {
        for (unsigned i = 0; i < listInterfaces_.size(); i++) {
            if (listInterfaces_[i].to_iface() == iface) {
                listInterfaces_.remove_from_list(i);
                break;
            }
        }
    }
 
    virtual IFace *getInterface(const char *name) {
        IFace *tmp;
        for (unsigned i = 0; i < listInterfaces_.size(); i++) {
            tmp = listInterfaces_[i].to_iface();
            if (strcmp(name, tmp->getFaceName()) == 0) {
                return tmp;
            }
        }
        return NULL;
    }
 
    virtual IFace *getPortInterface(const char *portname,
                                    const char *facename) {
        IFace *tmp;
        for (unsigned i = 0; i < listPorts_.size(); i++) {
            AttributeType &item = listPorts_[i];
            if (!item[0u].is_equal(portname)) {
                continue;
            }
            tmp = item[1].to_iface();
            if (strcmp(facename, tmp->getFaceName()) == 0) {
                return tmp;
            }
        }
        return NULL;
    }
 
    virtual void registerAttribute(const char *name, IAttribute *iface) {
        AttributeType item(iface);
        iface->allocAttrName(name);
        listAttributes_.add_to_list(&item);
    }
 
    virtual IAttribute *getAttribute(const char *name) {
        IAttribute *tmp;
        for (unsigned i = 0; i < listAttributes_.size(); i++) {
            tmp = static_cast<IAttribute *>(listAttributes_[i].to_iface());
            if (strcmp(name, tmp->getAttrName()) == 0) {
                return tmp;
            }
        }
        return NULL;
    }
 
    virtual const char *getObjName() { return obj_name_.to_string(); }
 
    virtual AttributeType getConfiguration() {
        AttributeType ret(Attr_Dict);
        ret["Name"] = AttributeType(getObjName());
        ret["Attr"] = AttributeType(Attr_List);
 
        IAttribute *tmp = NULL;
        for (unsigned i = 0; i < listAttributes_.size(); i++) {
            tmp = static_cast<IAttribute *>(listAttributes_[i].to_iface());
            AttributeType item;
            item.make_list(2);
            item[0u].make_string(tmp->getAttrName());
            item[1] = *static_cast<AttributeType *>(tmp);
            ret["Attr"].add_to_list(&item);
        }
        return ret;
    }
 
 protected:
    AttributeType listInterfaces_;
    AttributeType listPorts_;       // [['portname',iface],*]
    AttributeType listAttributes_;
    AttributeType logLevel_;
    AttributeType obj_name_;
};
 
}  // namespace debugger
 
#endif  // __DEBUGGER_COMMON_ISERVICE_H__