Register.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_REGISTER_HPP__
#define __NODAMUSHI_SVD_NORMALIZED_REGISTER_HPP__

# include <sstream>
# include "nodamushi/svd/normalized/node_container.hpp"
# include "nodamushi/svd/normalized/WriteConstraint.hpp"

namespace nodamushi{
namespace svd{
namespace normalized{


/*
 * Normalized register class.
 * if STRREF is string_view or something like it, 
 *  the reference source of string is the value of  nodamushi::svd::Register instance member.
 * 
 * @see http://www.keil.com/pack/doc/CMSIS/SVD/html/elem_registers.html#elem_register
 */

template<typename STRREF>struct Register
{
  using Field  = ::nodamushi::svd::normalized::Field<STRREF>;
  using Cluster= ::nodamushi::svd::normalized::Cluster<STRREF>;
  using Peripheral= ::nodamushi::svd::normalized::Peripheral<STRREF>;
  using this_t = Register<STRREF>;
  using p_ptr  = parent_ptr<Peripheral>;
  using p2_ptr = parent_ptr<Cluster>;
private:
  p_ptr  parent;  
  p2_ptr parent2; 

public:

  path<STRREF>         derivedFrom;
  std::string          name;
  std::string          displayName;
  dim_info             dim;
  STRREF               description;
  STRREF               alternateGroup;
  STRREF               alternateRegister;  
  uint64_t             addressOffset;
  nullable<uint32_t>   size;
  nullable<Access>     access;
  nullable<Protection> protection;
  nullable<uint64_t>   resetValue;
  nullable<uint64_t>   resetMask;
  nullable<DataType>   dataType;
  ModifiedWriteValues  modifiedWriteValues;
  ReadAction           readAction;
  WriteConstraint      writeConstraint;
  list<Field>          fields;

  //-----------------------------------------------------------
  std::string get_name_with_appendix()const noexcept{
    auto p = get_peripheral();
    if(p && p->has_register_name_appendix()){
      std::stringstream s;
      if(! p->prependToName.empty())
        s << p->prependToName;
      if(p->appendToName.empty())
        s << name;
      else{
        bool arr=dim.is_array() && name.length() > 3;
        if(arr){
          size_t l = name.length()-3;
          while(l != 1){
            if(name[l] == '[')break;
            l--;
          }
          if(name[l] == '['){
            s.write(name.data(),l);
          }else{
            s << name;
            arr = false;
          }
        }else
          s << name;
        s << p->appendToName;
        if(arr)
          s <<'['<<dim.index << ']';
      }
      return s.str();
    }
    return name;
  }
             
             
  
  node_ptr<Peripheral> get_parent() noexcept{return parent.lock();}
  node_ptr<Peripheral const> get_parent()const noexcept{return parent.lock();}

  node_ptr<Cluster>    get_parent2() noexcept{return parent2.lock();}
  node_ptr<Cluster const>    get_parent2()const noexcept{return parent2.lock();}
  node_ptr<Peripheral const> get_peripheral()const noexcept{return find_parent_peripheral(*this);}
  node_ptr<Peripheral> get_peripheral()noexcept{return find_parent_peripheral(*this);}
  uint64_t get_address()const{ return calc_address(*this);}
  uint64_t get_address_offset()const{ return calc_offset(*this);}
  ::nodamushi::svd::path<> get_path()const
  {
    ::nodamushi::svd::path<> p;
    path_helper(*this,p);
    return p;
  }
  DataType get_dataType()const{
    return dataType.get<this_t,get_default_dataType<this_t>>(this);
  }
  uint32_t get_size()const{
    return size.get<this_t,get_default_size<this_t>>(this);
  }
  uint64_t get_resetValue()const{
    return resetValue.get<this_t,get_default_resetValue<this_t>>(this);
  }
  uint64_t get_resetMask()const{
    return resetMask.get<this_t,get_default_resetMask<this_t>>(this);
  }
  Access get_access()const{
    return access.get<this_t,get_default_access<this_t>>(this);
  }
  Protection get_protection()const{
    return protection.get<this_t,get_default_protection<this_t>>(this);
  }
  ModifiedWriteValues get_modifiedWriteValues()const{return modifiedWriteValues;}
  ReadAction get_readAction()const{return readAction;}

  //-------------------------------------------
  template<typename STR>
  node_ptr<void> find(const ::nodamushi::svd::path<STR>& p,size_t pindex=0)
  {
    const size_t ps = p.size();
    if(ps > pindex){
      string_ref n = p[pindex];
      if(auto c = __find_helper(fields,n)){
        if(ps == pindex + 1)return c;
        else                return c->find(p,pindex+1);
      }
    }
    return {};
  }
  template<typename STR>
  node_ptr<Field> find_field(::nodamushi::svd::path<STR>& p,size_t pindex=0)
  {
    const size_t ps = p.size();
    if(ps == pindex+1){
      string_ref n = p[pindex];
      return __find_helper(fields,n);
    }
    return {};
  }

  //-------------------------------------------


  template<typename T>
  Register(const T& n)://don't change name
      parent(),
      parent2(),
      derivedFrom(),
      name(n.name),
      displayName(make_dim_displayName_helper(n.svd)(n.dim.index)),
      dim(n.dim),
      __NORMALIZED_DERIVED_FROM(description),
      __NORMALIZED_DERIVED_FROM(alternateGroup),
      __NORMALIZED_DERIVED_FROM(alternateRegister),
      __NORMALIZED_DERIVED_FROM(addressOffset),
      __NORMALIZED_DERIVED_FROM(size),
      __NORMALIZED_DERIVED_FROM(access),
      __NORMALIZED_DERIVED_FROM(protection),
      __NORMALIZED_DERIVED_FROM(resetValue),
      __NORMALIZED_DERIVED_FROM(resetMask),
      __NORMALIZED_DERIVED_FROM(dataType),
      __NORMALIZED_DERIVED_FROM(modifiedWriteValues),
      __NORMALIZED_DERIVED_FROM(readAction),
      __NORMALIZED_DERIVED_FROM_MEMBER(writeConstraint),
      fields(n.fields.size())
  {
    if(n.svd.derivedFrom)
      derivedFrom = n.svd.derivedFrom.get();

    // add dim offset
    if(n.dim && n.dim.index!=0){
      __NORMALIZED_DERIVED_FROM_HELPER(dimIncrement);
      size_t inc = 1;
      if(dimIncrement)
        inc = *dimIncrement;
      addressOffset += inc * n.dim.index;
    }

    for(const auto& f:n.fields)
      fields.emplace_back(f);
    // sort by lsb
    fields.sort([](const Field& a,const Field& b)->bool
                {return a.lsb() < b.lsb();});

  }
  void update_parent(p_ptr& new_parent,node_ptr<this_t>& me)
  {
    parent = new_parent;
    parent2= {};
    update_parent_of_children(fields,me);
  }
  void update_parent(p2_ptr& new_parent,node_ptr<this_t>& me)
  {
    parent2= new_parent;
    parent = {};
    update_parent_of_children(fields,me);
  }

};
//---------- Visitor --------------------
__NX_NORM_HANDLE_VISIT(Register)
{
  namespace nv = ::nodamushi::visitor;
  using r = nv::result;
  r ret;

  // visit register / cluster
  ret = CONTROLLER::apply(t.fields,v);
  if(ret == r::BREAK)return ret;
  if(ret == r::SKIP)return r::CONTINUE;
  return r::CONTINUE;
}};
//--------------------------------------------


}}} // end namespace svd

#endif // __NODAMUSHI_SVD_NORMALIZED_REGISTER_HPP__