Device.hpp

Go to the documentation of this file.

/*
 * These codes are licensed under CC0.
 * http://creativecommons.org/publicdomain/zero/1.0/
 */
#ifndef __NODAMUSHI_SVD_NORMALIZED_DEVICE_HPP__
#define __NODAMUSHI_SVD_NORMALIZED_DEVICE_HPP__

# include <ostream>
# include <memory>
# include "nodamushi/svd/normalized/node_container.hpp"
# include "nodamushi/svd/normalized/Cpu.hpp"

namespace nodamushi{
namespace svd{
namespace normalized{

template<typename STRREF>struct Device
{
  using this_t = Device<STRREF>;
  using Peripheral = ::nodamushi::svd::normalized::Peripheral<STRREF>;
  using Register=::nodamushi::svd::normalized::Register<STRREF>;
  using Cluster =::nodamushi::svd::normalized::Cluster<STRREF>;
  using Field=::nodamushi::svd::normalized::Field<STRREF>;
  using Cpu     =::nodamushi::svd::normalized::Cpu<STRREF>;

  STRREF           vendor;
  STRREF           vendorID;
  STRREF           name;
  STRREF           series;
  STRREF           version;
  STRREF           description;
  STRREF           licenseText;
  STRREF           headerSystemFilename;
  STRREF           headerDefinitionsPrefix;
  uint32_t         addressUnitBits;
  uint32_t         width;
  uint32_t         size;
  Access           access;
  Protection       protection;
  uint64_t         resetValue;
  uint64_t         resetMask;
  Cpu              cpu;

  list<Peripheral> peripherals;
  
  //----------------------------------------------------------
  template<typename STR>
  node_ptr<void> find(const ::nodamushi::svd::path<STR>& p)
  {
    if(p){
      string_ref n = p[0];
      if(auto c=__find_helper(peripherals,n)){
          if(p.size() == 1)return c;
          else             return c->find(p,1);
      }
    }
    return {};
  }
  node_ptr<void> find(string_ref p)
  {
    ::nodamushi::svd::path<> pa(p);
    return find(pa);
  }

  template<typename STR>
  node_ptr<Peripheral> find_peripheral(const ::nodamushi::svd::path<STR>& p)
  {
    if(p.size() == 1){
      string_ref n = p[0];
      return __find_helper(peripherals,n);
    }
    return {};
  }
  node_ptr<Peripheral> find_peripheral(string_ref p)
  {
    ::nodamushi::svd::path<> pa(p);
    return find_peripheral(pa);
  }

  template<typename STR>
  node_ptr<Cluster> find_cluster(const ::nodamushi::svd::path<STR>& p)
  {
    if(p.size() > 1){
      string_ref n = p[0];
      if(auto c=__find_helper(peripherals,n))
        return c->find_cluster(p,1);
    }
    return {};
  }
  node_ptr<Cluster> find_cluster(string_ref p)
  {
    ::nodamushi::svd::path<> pa(p);
    return find_cluster(pa);
  }
  
  template<typename STR>
  node_ptr<Register> find_register(const ::nodamushi::svd::path<STR>& p)
  {
    if(p.size() > 1){
      string_ref n = p[0];
      if(auto c=__find_helper(peripherals,n))
        return c->find_register(p,1);
    }
    return {};
  }
  node_ptr<Register> find_register(string_ref p)
  {
    ::nodamushi::svd::path<> pa(p);
    return find_register(pa);
  }
  
  template<typename STR>
  node_ptr<Field> find_field(const ::nodamushi::svd::path<STR>& p)
  {
    if(p.size() > 2){
      string_ref n = p[0];
      if(auto c=__find_helper(peripherals,n))
        return c->find_field(p,1);
    }
    return {};
  }
  node_ptr<Field> find_field(string_ref p)
  {
    ::nodamushi::svd::path<> pa(p);
    return find_field(pa);
  }
  
  //----------------------------------------------------------
  template<typename NORMALIZED>
  Device(const NORMALIZED& n)
      :vendor(n.svd.vendor.get("")),
       vendorID(n.svd.vendorID.get("")),
       name(n.svd.name.get("")),
       series(n.svd.series.get("")),
       version(n.svd.version.get("")),
       description(n.svd.description.get("")),
       licenseText(n.svd.licenseText.get("")),
       headerSystemFilename(n.svd.headerSystemFilename.get("")),
       headerDefinitionsPrefix(n.svd.headerDefinitionsPrefix.get("")),
       addressUnitBits(n.svd.addressUnitBits.get(8)), // default is 8?
       width(n.svd.width.get(32)), // default is 32?
       size(n.svd.size.get(32)),   // default is 32?
       access(n.svd.access.get(Access{})),
       protection(n.svd.protection.get(Protection{})),
       resetValue(n.svd.resetValue.get(0)),
       resetMask(n.svd.resetMask.get(~(uint64_t)0)),
       cpu(n.svd.cpu),
       peripherals(n.peripherals.size())
  {
    for(const auto& p:n.peripherals)
      peripherals.emplace_back(p);
  }
  
  void update_parent(node_ptr<Device>& this_ptr)
  {
    if(this_ptr.get() == this){
      update_parent_of_children(peripherals, this_ptr);
    }
  }
  uint64_t get_address()const{return 0;}
  uint32_t get_size()const{return size;}
  uint64_t get_resetValue()const{ return resetValue; }
  uint64_t get_resetMask()const{ return resetMask;}
  Access get_access()const{ return access;}
  Protection get_protection()const{ return protection;}
  constexpr const void* get_parent()const noexcept{return nullptr;}
  constexpr const void* get_parent2()const noexcept{return nullptr;}
};



//---------- Visitor --------------------
__NX_NORM_HANDLE_VISIT(Device)
{
  namespace nv = ::nodamushi::visitor;
  using r = nv::result;
  // visit Peripheral
  r ret;
  ret = CONTROLLER::apply(t.cpu,v);
  if(ret==r::BREAK)return r::BREAK;
  else if(ret == r::SKIP)return r::CONTINUE;
  ret = CONTROLLER::apply(t.peripherals,v);
  if(ret==r::BREAK)return r::BREAK;
  return r::CONTINUE;
}};
//----------------------------------------

}}}

#endif // __NODAMUSHI_SVD_NORMALIZED_DEVICE_HPP__