ipxact-dita 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: aba34808fe7475d865abcd1d30a4d046ecaf0619
+  data.tar.gz: 3bee2d0b76e862971362c6fbf22dcad034a4c17c
+SHA512:
+  metadata.gz: 460ce36f4cd53471c193cee767a91c5895f5083504d983c486dcc40e00805b0d0e1060dd76609205335fd2caa0f648a2b89c06f662d4e0db78e6cd86fe82e251
+  data.tar.gz: fc2f28345bec0a568f8e5c58c9ff948c26a153aa2acab531a18573090a14de6a4d955fa6501a2d0075bca3b543b3985408c0114a900f2ff7033355feb17906a8

data/lib/ipxact.rb

@@ -0,0 +1,11 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+require_relative 'ipxact/dita/reg_fig'
+require_relative 'ipxact/addr'
+
+module Ipxact
+  # @param node [Element] for now, just outputs one address from <ipxact:addressOffset/>
+  # @return [Element] table with columns for register name and address offset
+  def offset_table(node)
+    table(%w())
+  end
+end

data/lib/ipxact/addr.rb

@@ -0,0 +1,117 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+require 'con_duxml'
+require_relative 'ruby_ext/string'
+
+module Addr
+  include ConDuxml
+
+  HEX_POSTFIX = 'h'
+  HEX_PREFIX = '0x'
+  HEX_MAG_DIGS = 4
+  HEX_SEP = '_'
+
+  DEC_POSTFIX = 'd'
+  DEC_MAG_DIGS = 3
+  DEC_SEP = ','
+
+  BIN_POSTFIX = 'b'
+  BIN_PREFIX = '0b'
+  BIN_MAG_DIGS = 4
+  BIN_SEP = ' '
+
+  def bit_range
+    [position, position+width]
+  end
+
+  # @param str [String] string representing number; can be in any base
+  # @param opts [Hash] options are:
+  #   :pre  => true # radix notation goes at beginning e.g. '0x000F' - default setting
+  #   :post => true # radix notation goes at end e.g. 'Fh'
+  #   :sep  => true # adds separator characters ('_' for hex) every 4 digits
+  #   :pad  => [Fixnum] # given value indicates total digit width of number e.g. 4 => '000Fh'
+  # @return [String] string representation of hex number
+  def to_hex(str, opts={})
+    s = str.to_dec.to_s(16).upcase
+    s = add_padding(s, opts[:pad]) if opts[:pad]
+
+    if opts[:sep]
+      separator = opts[:sep] == true ? HEX_SEP : opts[:sep]
+      s = add_separators(s, HEX_MAG_DIGS, separator)
+    end
+
+    if opts[:post]
+      s += opts[:post] == true ? HEX_POSTFIX : opts[:post]
+    end
+    if opts[:pre]
+      s = opts[:pre] == true ? HEX_PREFIX : opts[:pre] + s
+    end
+    s
+  end
+
+  # @param str [String] string representing number; can be in any base
+  # @param opts [Hash] options are:
+  #   :pre  => [boolean, String] # if String, notation, by default '0b'; hash key indicates position; if true,
+  #   :post => [boolean, String] # radix notation goes at end e.g. '10b'; cannot contradict :pre
+  #   :sep  => [boolean] # adds separator characters ('_' for hex) every 4 digits
+  #   :pad  => [Fixnum] # given value indicates total digit width of number e.g. 4 => '000Fh'
+  # @return [String] string representation of hex number
+  def to_bin(str, opts={})
+    s = str.to_dec.to_s(2)
+    s = add_padding(s, 1) if opts[:pad]
+
+    if opts[:sep]
+      separator = opts[:sep] == true ? BIN_SEP : opts[:sep]
+      s = add_separators(s, BIN_MAG_DIGS, separator)
+    end
+
+    if opts[:post]
+      s += opts[:post] == true ? BIN_POSTFIX : opts[:post]
+    end
+    if opts[:pre]
+      s = (opts[:pre] == true ? BIN_PREFIX : opts[:pre]) + s
+    end
+    s
+  end
+
+  # @param str [String] number as string; can be any base or notation
+  # @return [String] formatted string
+  def to_dec(str, opts={})
+    s = str.to_dec.to_s
+    s = add_padding(s, opts[:pad])     if opts[:pad]
+
+    if opts[:sep]
+      separator = opts[:sep] == true ? DEC_SEP : opts[:sep]
+      s = add_separators(s, DEC_MAG_DIGS, separator)
+    end
+
+    if opts[:post]
+      s += opts[:post] == true ? DEC_POSTFIX : opts[:post]
+    end
+    s
+  end
+
+  # @param str [String] number as string
+  # @param places [Fixnum] number of digits for the whole number
+  # @return [String] string representing number
+  def add_padding(str, places)
+    padding = ''
+    (places - str.size).times do padding << '0' end
+    padding + str
+  end
+
+  def add_separators(str, mag, sep)
+    expr = Regexp.new("\\w{#{mag}}")
+    s = str.reverse.gsub(expr) do |m| m+sep end.reverse
+    str.size%mag == 0 ? s[1..-1] : s
+  end
+
+  private :add_separators, :add_padding
+
+  private
+
+  def get_bin_value
+    av = reset_value.value
+    self[:value].to_s(2).split(//)
+  end
+end

data/lib/ipxact/dita/fig_field.rb

@@ -0,0 +1,117 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+module Ipxact
+  REGFIG_MAX_ROWBITS = 32
+
+  module FigField
+    include Dita
+
+    @field
+
+    def gen_field_entries(_field, _word_ct)
+      @field = _field
+      @word_ct = _word_ct
+
+      entry = Element.new('entry')
+      if width == 1
+        entry[:colname] = col_start_index.to_s
+      else
+        entry[:namest] = (col_start_index).to_s
+        entry[:nameend] = (col_end_index+1).to_s
+      end
+      entry[:valign] = 'middle'
+      # entry[:outputclass] = 'rotate' if get_bit_width(name) > fig_bit_width # TODO fix this!!!
+      entries = gen_field_access(entry)
+      #entries << get_value_entries
+    end
+
+    private
+
+    attr_reader :word_ct, :field
+
+    def gen_field_access(entry)
+      read = entry
+      write = Element.new('entry')
+
+      #TODO pull out into Duxml#dclone?
+      entry.attributes.each do |k,v| write[k] = v end
+      unless readable?
+        read[:outputclass] = 'shaded'
+      end
+      if readable? == writable?
+        read[:morerows] = '1'
+        name = readable? ? gen_field_name(read) : 'Reserved'
+        return [name]
+      elsif !writable?
+        gen_field_name(read)
+        write[:outputclass] = 'shaded'
+      elsif !readable?
+        gen_field_name(write)
+      else
+        # do nothing
+      end
+      [read, write]
+    end
+
+    def readable?
+      access = field.locate('ipxact:access').first
+      access = source.access.text unless access
+      access.include?('read')
+    end
+
+    def writable?
+      access = field.locate('ipxact:access').first
+      access = source.access.text unless access
+      access.include?('write')
+    end
+
+    def get_value_entries
+      v = []
+      width.times do |i|
+        b = bits[i] ? bits[i] : 0
+        v << e = Element.new('entry')
+        e << b.to_s
+      end
+      v
+    end
+
+    def gen_field_name(entry)
+      if field_name.nil?
+        entry << '-'
+      else
+        entry << Element.new('xref')
+        entry.xref[:href] = get_xref
+        entry.xref << field_name
+      end
+      entry
+    end
+
+    def field_name
+      n = field.locate('ipxact:name')
+      n.empty? ? nil : n.first.text
+    end
+
+    def get_xref
+      "NOT_IMPLEMENTED" # TODO
+    end
+
+    def col_end_index
+      ms_pos - word_ct * REGFIG_MAX_ROWBITS
+    end
+
+    def col_start_index
+      ls_pos - word_ct * REGFIG_MAX_ROWBITS + 1
+    end
+
+    def width
+      field.bitWidth.text.to_i
+    end
+
+    def ls_pos
+      field.bitOffset.text.to_i
+    end
+
+    def ms_pos
+      field.bitOffset.text.to_i + field.bitWidth.text.to_i - 1
+    end
+  end
+end

data/lib/ipxact/dita/reg_fig.rb

@@ -0,0 +1,113 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+require 'con_duxml'
+require 'ruby-dita'
+require_relative 'fig_field'
+
+module Ipxact
+  include Dita
+  include FigField
+
+  # counts number of words of figure generated so far, where size of word is defined by REGFIG_MAX_ROWBITS
+  @word_ct
+
+  attr_reader :word_ct
+
+  # @param opts [Hash] no options currently supported TODO add options for hide access, hide reset value, etc.
+  # @return [Element] visual rendering of register and its fields in Dita table form; content from <ipxact:register/> in @source
+  def reg_fig(opts={})
+    src = source # TODO not sure if this is ideal, but works for now
+    table = Element.new('table')
+    table[:id] = object_id.to_s+"_regFigure"
+    table[:frame] = 'all'
+    table[:outputclass] = 'crr.regFigure regtable'
+    @word_ct = 0
+    input = src.locate(src_ns + ':field')
+    tgroup = nil
+    until input.empty? do
+      field = input.pop
+      index = row_relative_index field
+      if tgroup.nil?
+        tgroup = gen_tgroup
+        table << tgroup
+      end
+      if index > REGFIG_MAX_ROWBITS
+        table << tgroup = gen_tgroup
+        input << field.split do |bit| bit end
+        next
+      else
+        entries = gen_field_entries(field, word_ct)
+        tgroup.tbody.nodes[1] << entries.first
+        tgroup.tbody.nodes[2] << entries[1] if entries.size > 2
+        tgroup.tbody.nodes[3] << entries.last if entries.last.is_a?(Array)
+      end
+      if field_pos(field) == 0 || index >= REGFIG_MAX_ROWBITS
+        @word_ct += 1 unless field_pos(field) == 0
+      end
+    end
+    table
+  end
+
+  def row_relative_index(field)
+    field_pos(field) + field_width(field) - word_ct*REGFIG_MAX_ROWBITS
+  end
+
+  def small?
+    reg_size < REGFIG_MAX_ROWBITS
+  end
+
+  def large?
+    reg_size > 64
+  end
+
+  def field_pos(field)
+    field.bitOffset.text.to_i
+  end
+
+  def field_width(field)
+    field.bitWidth.text.to_i
+  end
+
+  def gen_tgroup
+    tgroup = Element.new('tgroup')
+    tgroup[:cols] ||= num_cols
+    num_cols.times do |i|
+      tgroup << colspec = Element.new('colspec')
+      colspec[:align] = 'center'
+      colspec[:colname] = i.to_s
+    end
+
+    tgroup << Element.new('tbody')
+    %w(Bits R W Reset).each do |heading|
+      tgroup.tbody << row = Element.new('row')
+      row << Element.new('entry')
+      row.entry << heading
+    end
+
+    set_bit_heading! tgroup.tbody.nodes.first
+    tgroup
+  end
+
+  def set_bit_heading!(bit_row)
+    fig_bit_width.times do |i|
+      bit_row << e = Element.new('entry')
+      e << (fig_bit_width - i-1).to_s
+    end
+  end
+
+  def reg_size
+    source.size.text.to_i
+  end
+
+  def fig_bit_width
+    REGFIG_MAX_ROWBITS > reg_size ? reg_size : REGFIG_MAX_ROWBITS
+  end
+
+  def bit_range
+    "#{(field_pos(source) + field_width(source) - 1).to_s} - #{field_pos(source).to_s}"
+  end
+
+  def num_cols
+    fig_bit_width+1
+  end
+end

data/lib/ipxact/ruby_ext/string.rb

@@ -0,0 +1,34 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+PREFIX_HEX = /^('h|0x)[0-9A-Fa-f]+$/
+POSTFIX_HEX = /^[0-9A-Fa-f]+h$/
+PREFIX_BIN = /^['0]b[01]+$/
+POSTFIX_BIN = /^[0-1]+b$/
+DECIMAL = /^[0-9]+$/
+NAKED_HEX = /^[0-9A-Fa-f]+$/
+
+class String
+  # @return [Fixnum] returns base of number represented by this string e.g. '0x0F' => 16
+  def base
+    case self
+      when PREFIX_BIN, POSTFIX_BIN
+        2
+      when PREFIX_HEX, POSTFIX_HEX, NAKED_HEX
+        16
+      when DECIMAL
+        10
+      else
+        nil
+    end
+  end
+
+  # @return [Fixnum] returns numerical value of string in decimal form
+  def to_dec
+    case self
+      when PREFIX_BIN, PREFIX_HEX   then self[2..-1]
+      when POSTFIX_HEX, POSTFIX_BIN then self[0..-2]
+      when DECIMAL, NAKED_HEX       then self
+      else
+        raise Exception, "'#{self}' is not a numerical string!"
+    end.to_i(base)
+  end
+end

data/lib/ipxact/vendor_extensions/magillem_ipxact.rb

@@ -0,0 +1,9 @@
+require 'ipxact'
+
+module Ipxact
+  module Magillem
+    def do_something
+
+    end
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: ipxact-dita
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Peter Kong
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: duxml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.6
+- !ruby/object:Gem::Dependency
+  name: ruby-dita
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+description: see README.md
+email:
+- peter.kong@nxp.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ipxact/addr.rb
+- lib/ipxact/dita/fig_field.rb
+- lib/ipxact/dita/reg_fig.rb
+- lib/ipxact/ruby_ext/string.rb
+- lib/ipxact/vendor_extensions/magillem_ipxact.rb
+- lib/ipxact.rb
+homepage: http://www.github.com/Ludocracy/ip-xact
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.8.11
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14.1
+signing_key: 
+specification_version: 4
+summary: Ruby interface for IP-XACT semiconductor component model including documentation
+  generation
+test_files: []