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 all interfaces

    @ifc_lib      = {}

    # we remember paths, which we've already processed

    @path_lut = []

  end

  def clear

    @cores_lib.clear

    @ifc_lib.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 )

    # save core

    @cores_lib[ core.id ] = core

    SOCMaker::logger.info  "loaded "     +

                            core.name     +

                            ", id =  "   +

                            core.id

  end

  def get_core( id )

    tmp = @cores_lib[ id ]

    check_nil( tmp, "Core with id '#{id}' does not exist" )

    return tmp

  end

  def rm_core( arg )

    if arg.is_a?( String )

      check_nil( @cores_lib[ arg ], "Core with id '#{arg}' does not exist" )

      @cores_lib.delete( arg )

    elsif arg.is_a?( SOCMaker::CoreDef )

      check_nil( @cores_lib[ arg.id ], "Core with id '#{arg.id}' does not exist" )

      @cores_lib.delete( arg.id )

    else

      raise SOCMaker::ERR::LibError.new( "", "FATAL: Can't remove interface" )

    end

  end

  def add_ifc( ifc )

    @ifc_lib[ ifc.id ] = ifc

  end

  def get_ifc( id )

    tmp = @ifc_lib[ id ]

    check_nil( tmp, "Interface with id '#{id}' does not exist" )

    return tmp

  end

  def rm_ifc( arg )

    if arg.is_a?( String )

      check_nil( @ifc_lib[ arg ],

            "Interface with id '#{arg}' does not exist" )

      @ifc_lib.delete( arg )

    elsif arg.is_a?( SOCMaker::IfcSpc )

      check_nil( @ifc_lib[ arg.id ],

            "Interface with id '#{arg.id}' does not exist" )

      @ifc_lib.delete( arg.id )

    else

      raise SOCMaker::ERR::LibError.new( "", "FATAL: Can't remove interface" )

    end

  end

  def to_s

      "IP-Core - lib: \n"             +

      @cores_lib.keys.to_s            +

      "\n\nIP-Interfaces - lib: \n"    +

      @ifc_lib.keys.to_s

  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 |id,core|

      yield( id.to_s, core )

    end

  end

end #class Lib

end #Module SOCMaker

#

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