Subversion Repositories soc_maker

###############################################################

#

#  File:      spc_lib.rb

#

#  Author:    Christian Hättich

#

#  Project:   System-On-Chip Maker

#

#  Target:    Linux / Windows / Mac

#

#  Language:  ruby

#

#

###############################################################

#

#

#   Copyright (C) 2014  Christian Hättich  - feddischson [ at ] opencores.org

#

#   This program is free software: you can redistribute it and/or modify

#   it under the terms of the GNU General Public License as published by

#   the Free Software Foundation, either version 3 of the License, or

#   (at your option) any later version.

#

#   This program is distributed in the hope that it will be useful,

#   but WITHOUT ANY WARRANTY; without even the implied warranty of

#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

#   GNU General Public License for more details.

#

#   You should have received a copy of the GNU General Public License

#   along with this program.  If not, see .

#

#

###############################################################

#

#   Description:

#     This class represents the library, which holds all

#       - cores (core-definitions)

#       - interfaces (interface-specifications)

#

#

####

#

#

#

###############################################################

module SOCMaker

class Lib

  include ERR

  def initialize

    # will store all cores

    @cores_lib      = {}

    # will store the versions of all cores { name => { ver1, ver2, ver3 } }

    @cores_ver  = {}

    # will store all interfaces

    @ifc_lib      = {}

    # will store the versions of all interfaces { name => { ver1, ver2, ver3 } }

    @ifc_ver  = {}

    # we remember paths, which we've already processed

    @path_lut = []

  end

  def clear

    @cores_lib.clear

    @cores_ver.clear

    @ifc_lib.clear

    @ifc_ver.clear

    @path_lut.clear

  end

  # refreshes the core library:

  # it useses the global configuration entry cores_search_path,

  # which defines, where to search for inc_fname (defined in soc_maker_conf.rb) files.

  # For each directory, we call process_include

  def refresh( paths = nil )

    paths = [ paths ] if paths.is_a?( String )

    SOCMaker::logger.info  "START REFRESHING CORE LIBRARY"

    # clear the libs

    clear

    # use argument if given, otherwise config paths

    paths ||= SOCMaker::conf[ :cores_search_path ]

    paths.each do |dir|

      process_include dir

    end

    SOCMaker::logger.info  "DONE REFRESHING CORE LIBRARY"

  end

  def process_include( dir )

    #

    # this prevents the revursive call

    # from an infinite call

    #

    folder_sym = File.expand_path( dir ).to_sym

    lerr_if( @path_lut.include?( folder_sym ),

        "double-include: infinite resursive search?" )

    @path_lut << folder_sym

    # get all yaml files in the directory

    SOCMaker::logger.info  "search for include in: " + dir

    SOCMaker::from_s( get_all_yaml_in_str( dir ) ) do |o|

      o.dir = dir

      case o

      when SOCMaker::LibInc

        add_include( o, dir )

      when SOCMaker::CoreDef

        add_core( o )

      when SOCMaker::SOCDef

        add_core( o )

      when SOCMaker::IfcSpc

        add_ifc( o )

      else

        #TODO add error

      end

    end

  end

  def get_all_yaml_in_str( dir )

    yaml_str = ""

    Dir[ File.join( dir, "*.yaml" ) ].sort.each do |yaml_file|

      SOCMaker::logger.info "reading:" + yaml_file

      yaml_str << File.read( yaml_file )

    end

    return yaml_str

  end

  # gets an SOCMaker::LibInc object and iterates

  # over all folders.

  # Note: this is moved from process_include to this extra function

  # to support test capability

  def add_include( soc_inc_object, dir )

    soc_inc_object.dirs.each { |d| process_include( File.expand_path( File.join( dir, d ) ) ) }

  end

  def add_core( core )

    # generate key-string from name and vesion

    core_key = core.name + core.version

    # save core

    @cores_lib[ core_key ] = core

    @cores_ver[ core.name.to_sym ] = [] unless @cores_ver.has_key?(core.name.to_sym)

    @cores_ver[ core.name.to_sym ] << core.version

    SOCMaker::logger.info  "loaded "     +

                            core.name     +

                            " version "   +

                            core.version

  end

  def get_core( name, version = "" )

    core_key = name + version

    tmp = @cores_lib[ core_key ]

    check_nil( tmp, "Core '#{name}' version '#{version}' does not exist" )

    return tmp

  end

  def rm_core( core )

    core_key = core.name + core.version

    @cores_lib.delete( core_key )

  end

  def add_ifc( ifc )

    ifc_key = ifc.name + ifc.version

    @ifc_lib[ ifc_key         ] = ifc

    @ifc_ver[ ifc.name.to_sym ] = [] unless @ifc_ver.has_key?(ifc.name.to_sym)

    @ifc_ver[ ifc.name.to_sym ] << ifc.version

  end

  def get_ifc( name, version = "" )

    ifc_key = name + version

    tmp = @ifc_lib[ ifc_key ]

    check_nil( tmp, "Interface '#{name}' version '#{version}' does not exist" )

    return tmp

  end

  def rm_ifc( ifc )

    ifc_key = ifc.name + ifc.version

    @ifc_lib.delete( ifc_key )

  end

  def to_s

      "IP-Core - lib: \n"             +

      @cores_lib.keys.to_s            +

      "\n\nIP-Core - versions: \n"    +

      @cores_ver.to_s                 +

      "\n\nInterface - lib: \n"       +

      @ifc_lib.keys.to_s              +

      "\n\nInterface - versions: \n"  +

      @ifc_ver.to_s  + "\n"

  end

  def check_nil( var, error_msg = "")

    if var == nil

      SOCMaker::logger.error error_msg

      raise SOCMaker::ERR::LibError.new( "", error_msg )

    end

  end

  #

  # get all interfaces in a list

  #

  # TODO untested: do we need this?

  def get_ifcs( core )

    ifc_list = [];

    core.interfaces.values.each do |ifc; ifc_tmp|

      ifc_tmp = get_ifc( ifc[ :name ], ifc[ :version ] )

      # error handling

      if ifc_tmp == nil

        SOCMaker::logger.error  "Can't find #{ifc[ :name ]} version #{ifc[ :version ]} in SOC library"

        raise NameError, "Can't find #{ifc[ :name ]} version #{ifc[ :version ]} in SOC library"

      end

      # add interface to list

      ifc_list << ifc_tmp

    end

    return ifc_list

  end

  #

  # TODO add test code

  #

  def cores

    @cores_lib.each do |nameversion,core|

      yield( nameversion.to_s, core )

    end

  end

end #class Lib

end #Module SOCMaker

#

# vim: noai:ts=2:sw=2