soc_maker 0.1.1

data/examples/or1200_test/sw/uart.h

@@ -0,0 +1,126 @@
+#define UART_RX		0	/* In:  Receive buffer (DLAB=0) */
+#define UART_TX		0	/* Out: Transmit buffer (DLAB=0) */
+#define UART_DLL	0	/* Out: Divisor Latch Low (DLAB=1) */
+#define UART_DLM	1	/* Out: Divisor Latch High (DLAB=1) */
+#define UART_IER	1	/* Out: Interrupt Enable Register */
+#define UART_IIR	2	/* In:  Interrupt ID Register */
+#define UART_FCR	2	/* Out: FIFO Control Register */
+#define UART_EFR	2	/* I/O: Extended Features Register */
+				/* (DLAB=1, 16C660 only) */
+#define UART_LCR	3	/* Out: Line Control Register */
+#define UART_MCR	4	/* Out: Modem Control Register */
+#define UART_LSR	5	/* In:  Line Status Register */
+#define UART_MSR	6	/* In:  Modem Status Register */
+#define UART_SCR	7	/* I/O: Scratch Register */
+
+/*
+ * These are the definitions for the FIFO Control Register
+ * (16650 only)
+ */
+#define UART_FCR_ENABLE_FIFO	0x01 /* Enable the FIFO */
+#define UART_FCR_CLEAR_RCVR	0x02 /* Clear the RCVR FIFO */
+#define UART_FCR_CLEAR_XMIT	0x04 /* Clear the XMIT FIFO */
+#define UART_FCR_DMA_SELECT	0x08 /* For DMA applications */
+#define UART_FCR_TRIGGER_MASK	0xC0 /* Mask for the FIFO trigger range */
+#define UART_FCR_TRIGGER_1	0x00 /* Mask for trigger set at 1 */
+#define UART_FCR_TRIGGER_4	0x40 /* Mask for trigger set at 4 */
+#define UART_FCR_TRIGGER_8	0x80 /* Mask for trigger set at 8 */
+#define UART_FCR_TRIGGER_14	0xC0 /* Mask for trigger set at 14 */
+
+/* 16650 redefinitions */
+#define UART_FCR6_R_TRIGGER_8	0x00 /* Mask for receive trigger set at 1 */
+#define UART_FCR6_R_TRIGGER_16	0x40 /* Mask for receive trigger set at 4 */
+#define UART_FCR6_R_TRIGGER_24  0x80 /* Mask for receive trigger set at 8 */
+#define UART_FCR6_R_TRIGGER_28	0xC0 /* Mask for receive trigger set at 14 */
+#define UART_FCR6_T_TRIGGER_16	0x00 /* Mask for transmit trigger set at 16 */
+#define UART_FCR6_T_TRIGGER_8	0x10 /* Mask for transmit trigger set at 8 */
+#define UART_FCR6_T_TRIGGER_24  0x20 /* Mask for transmit trigger set at 24 */
+#define UART_FCR6_T_TRIGGER_30	0x30 /* Mask for transmit trigger set at 30 */
+
+/*
+ * These are the definitions for the Line Control Register
+ * 
+ * Note: if the word length is 5 bits (UART_LCR_WLEN5), then setting 
+ * UART_LCR_STOP will select 1.5 stop bits, not 2 stop bits.
+ */
+#define UART_LCR_DLAB	0x80	/* Divisor latch access bit */
+#define UART_LCR_SBC	0x40	/* Set break control */
+#define UART_LCR_SPAR	0x20	/* Stick parity (?) */
+#define UART_LCR_EPAR	0x10	/* Even parity select */
+#define UART_LCR_PARITY	0x08	/* Parity Enable */
+#define UART_LCR_STOP	0x04	/* Stop bits: 0=1 stop bit, 1= 2 stop bits */
+#define UART_LCR_WLEN5  0x00	/* Wordlength: 5 bits */
+#define UART_LCR_WLEN6  0x01	/* Wordlength: 6 bits */
+#define UART_LCR_WLEN7  0x02	/* Wordlength: 7 bits */
+#define UART_LCR_WLEN8  0x03	/* Wordlength: 8 bits */
+
+/*
+ * These are the definitions for the Line Status Register
+ */
+#define UART_LSR_TEMT	0x40	/* Transmitter empty */
+#define UART_LSR_THRE	0x20	/* Transmit-hold-register empty */
+#define UART_LSR_BI	0x10	/* Break interrupt indicator */
+#define UART_LSR_FE	0x08	/* Frame error indicator */
+#define UART_LSR_PE	0x04	/* Parity error indicator */
+#define UART_LSR_OE	0x02	/* Overrun error indicator */
+#define UART_LSR_DR	0x01	/* Receiver data ready */
+
+/*
+ * These are the definitions for the Interrupt Identification Register
+ */
+#define UART_IIR_NO_INT	0x01	/* No interrupts pending */
+#define UART_IIR_ID	0x06	/* Mask for the interrupt ID */
+
+#define UART_IIR_MSI	0x00	/* Modem status interrupt */
+#define UART_IIR_THRI	0x02	/* Transmitter holding register empty */
+#define UART_IIR_TOI	0x0c	/* Receive time out interrupt */
+#define UART_IIR_RDI	0x04	/* Receiver data interrupt */
+#define UART_IIR_RLSI	0x06	/* Receiver line status interrupt */
+
+/*
+ * These are the definitions for the Interrupt Enable Register
+ */
+#define UART_IER_MSI	0x08	/* Enable Modem status interrupt */
+#define UART_IER_RLSI	0x04	/* Enable receiver line status interrupt */
+#define UART_IER_THRI	0x02	/* Enable Transmitter holding register int. */
+#define UART_IER_RDI	0x01	/* Enable receiver data interrupt */
+
+/*
+ * These are the definitions for the Modem Control Register
+ */
+#define UART_MCR_LOOP	0x10	/* Enable loopback test mode */
+#define UART_MCR_OUT2	0x08	/* Out2 complement */
+#define UART_MCR_OUT1	0x04	/* Out1 complement */
+#define UART_MCR_RTS	0x02	/* RTS complement */
+#define UART_MCR_DTR	0x01	/* DTR complement */
+
+/*
+ * These are the definitions for the Modem Status Register
+ */
+#define UART_MSR_DCD	0x80	/* Data Carrier Detect */
+#define UART_MSR_RI	0x40	/* Ring Indicator */
+#define UART_MSR_DSR	0x20	/* Data Set Ready */
+#define UART_MSR_CTS	0x10	/* Clear to Send */
+#define UART_MSR_DDCD	0x08	/* Delta DCD */
+#define UART_MSR_TERI	0x04	/* Trailing edge ring indicator */
+#define UART_MSR_DDSR	0x02	/* Delta DSR */
+#define UART_MSR_DCTS	0x01	/* Delta CTS */
+#define UART_MSR_ANY_DELTA 0x0F	/* Any of the delta bits! */
+
+/*
+ * These are the definitions for the Extended Features Register
+ * (StarTech 16C660 only, when DLAB=1)
+ */
+#define UART_EFR_CTS	0x80	/* CTS flow control */
+#define UART_EFR_RTS	0x40	/* RTS flow control */
+#define UART_EFR_SCD	0x20	/* Special character detect */
+#define UART_EFR_ENI	0x10	/* Enhanced Interrupt */
+
+
+void uart_init(unsigned long);
+void uart_putc(char);
+char uart_getc(void);
+void uart_print_str(char *);
+void uart_print_long(unsigned long);
+void uart_interrupt();
+void uart_print_short(unsigned long ul);

data/lib/soc_maker.rb

@@ -0,0 +1,324 @@
+###############################################################
+#   
+#  File:      soc_maker.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 <http://www.gnu.org/licenses/>.
+#
+#
+###############################################################
+#
+#   Description:
+#     This part of the SOCMaker module contains
+#       - initialization of
+#         - logger
+#         - configuration
+#         - library
+#         (see SOCMaker::load)
+#       - creating objects from YAML files/strings
+#         (see from_f, from_s)
+#       - creating YAML files from objects
+#         (see SOCMaker::YAML_EXT::write_yaml)
+#   
+#
+#
+###############################################################
+require 'logger'
+require 'yaml'
+require 'digest/md5'
+require 'fileutils'
+
+
+#
+# This little extension allows to have a custom log level: PROC for processing.
+# Found on
+# http://stackoverflow.com/questions/2281490/how-to-add-a-custom-log-level-to-logger-in-ruby
+class Logger
+
+  # 
+  # Method to add a custom log level
+  #
+  def self.custom_level(tag)
+    SEV_LABEL << tag 
+    idx = SEV_LABEL.size - 1 
+
+    define_method(tag.downcase.gsub(/\W+/, '_').to_sym) do |progname, &block|
+      add(idx, nil, progname, &block)
+    end 
+  end 
+  # add processing log level
+  custom_level 'PROC'
+end
+
+
+
+module SOCMaker
+
+  #
+  # Static methods and attributes
+  #
+  class << self
+    public
+
+    # The global logging instance
+    attr_accessor :logger
+
+    # The global configuration
+    attr_accessor :conf
+
+    # The global library
+    attr_accessor :lib
+
+    #
+    # Global initialization method: this loads the config and
+    # refreshes the core library.
+    # Typically, this is the first method which is called during initialization.
+    #
+    # *options*:: 
+    #     - skip_refresh=true/false: can be used to skip refreshing the core library
+    #     - logger_out=<any file stream>: default is STDOUT, can be used to put the log into a file
+    #
+    #             
+    #
+    def load( options={} )
+      options = { skip_refresh: false, logger_out: STDOUT }.merge( options )
+      @conf   = Conf.instance
+      @logger = Logger.new(options[ :logger_out ] )
+      @lib    = Lib.new()
+      @logger.progname = @conf[ :app_name ]
+      @lib.refresh( options[ :libpath ] ) unless options[ :skip_refresh ]
+    end
+
+
+
+    #
+    # Funtion to load a object from a YAML string.
+    # This includes the YPP,
+    # which replaces our custom object tags with yaml 
+    # object information.
+    # Afterwards, the method YAML::load is used
+    # to create the object.
+    #
+    # In addition, it is possible to provide multiple objects in
+    # one string: YPP takes care and splits them into 
+    # single object strings.
+    #
+    # *s*:: the object(s) as yaml string (before processing with YPP)
+    # 
+    #
+    def from_s( s )
+
+      objs = []
+      SOCMaker::YPP.to_yaml( s ) do |yaml_obj_str|
+
+        begin
+          YAML::load( yaml_obj_str )
+          o = YAML::load( yaml_obj_str )
+
+          # ensure, that we load only our classes
+          if SOCMaker::conf[ :yaml_classes ].include?( o.class )
+            #o.verify
+            objs << o
+          else
+            SOCMaker::logger.warn( "Tried to load something, which does not belong to #{SOCMaker::conf[ :app_name ]}" )
+          end
+        rescue ArgumentError, Psych::SyntaxError => e
+          SOCMaker::logger.error( 'YAML loading failed, invalid YAML syntax?' )
+          SOCMaker::logger.error( ">>> #{e.to_s} <<<" )
+          raise ERR::YAMLParseError
+        else
+        end
+      end
+
+      if block_given?
+        objs.each{ |o| yield(o) }
+      end
+      return ( objs.size >1 ? objs : objs[0] )
+    end
+
+    #
+    # Method to load a yaml-based object(s) from one
+    # or multiple files. The files are read and concatenated. 
+    # Path argument can be an array of paths
+    # or a file (wildcards are allowed)
+    # loading from a YAML file
+    def from_f( path )
+
+      path = Dir[ path ].sort if path.is_a?( String )
+
+      SOCMaker::logger.warn( "No file(s) found to load" ) if path.size == 0
+
+      yaml_str = ""
+      path.each do |file|
+        SOCMaker::logger.info "reading:" + file
+        yaml_str << File.read( file )
+      end
+      o = from_s( yaml_str )
+      o.src_dir = File.dirname( path.first )
+      return o
+    end
+
+    #
+    # This method takes an object, converts it to a YAML string and 
+    # also applies the YPP to replace the YAML object-tags.
+    #
+    def to_yaml_s( o )
+      YPP.from_yaml( o.to_yaml )
+    end
+
+
+    #
+    # Deployes a System-on-Chip:
+    # - get all core-ids
+    # - get all static parameters
+    # - call deploy for each core which causes to copy and generate all HDL files
+    # *soc*:: the System-on-Chip, which is deployed
+    # *coder*:: the choosen HDL coder
+    #
+    def deploy_soc( soc, coder = VHDLCoder.new )
+
+      SOCMaker::logger.info "Deploying SOC #{soc.name}"
+      soc.consistence_check
+      ids = soc.all_core_id
+      static = soc.all_static_parameters
+      static = check_static_setup( static )
+
+      SOCMaker::logger.info "Core Occurrence"
+      SOCMaker::CoreDef.core_cnt( ids ).each do |k,v|
+        SOCMaker::logger.info "#{k}\t#{v}"
+      end
+      ids.uniq.each{ |core| lib.get_core( core ).deploy( coder: coder, static: static ) }
+
+    end
+
+
+    #
+    # Ensure, that there are no multiple defined static parameters
+    # for a core/soc.
+    # *static*:: Input hash with the structure { soc_id : { core_id1: { .... }, core_id2: { .... } } }
+    # *return*:: Output hash with the structure { core_id1: { ....}, core_id2: { .... } }
+    #
+    def check_static_setup( static )
+      static_tmp = {}
+      static.each do |core_id, static_setup|
+        static_setup.each do |core_id2, value |
+          if static_tmp.has_key?( core_id2 )
+            raise ConsistenceError.new( "Invalid static setup: #{core_id2} is defined multiple times" ) 
+          end
+          static_tmp[ core_id2 ] = value
+        end
+      end
+      return static_tmp
+    end
+
+
+  end
+
+
+
+  #
+  # small module to extend classes,
+  # which need to be written as yaml 
+  # output
+  module YAML_EXT 
+
+    # we remember always, were we've loaded a yaml file
+    attr_accessor :src_dir
+
+    def save_yaml( args )
+      path =  args.size==0 ? @spec_path : args.first
+      File.open( path, 'w') {|f| f.write SOCMaker::YPP.from_yaml( YAML.dump( self ) ) } 
+    end
+  end 
+
+
+
+
+
+
+  # :stopdoc:
+  LIBPATH = ::File.expand_path('..', __FILE__) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    rv =  args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+    if block_given?
+      begin
+        $LOAD_PATH.unshift LIBPATH
+        rv = yield
+      ensure
+        $LOAD_PATH.shift
+      end
+    end
+    return rv
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    rv = args.empty? ? PATH : ::File.join(PATH, args.flatten)
+    if block_given?
+      begin
+        $LOAD_PATH.unshift PATH
+        rv = yield
+      ensure
+        $LOAD_PATH.shift
+      end
+    end
+    return rv
+  end
+
+  #
+  # load all file for soc_maker
+  #
+  def self.require_all_libs
+    file  = ::File.basename(__FILE__, '.*')
+    dir = ::File.dirname(__FILE__)
+    %w[ err         ypp         
+        lib_inc     version
+        core_def    core_inst 
+        hdl_file    ifc_def
+        ifc_port    ifc_spc
+        soc_def     parameter 
+        sparameter  hdl_coder
+        lib cli conf 
+        hdl_parser ].each { |rb| require ::File.expand_path(
+                  ::File.join( dir, file, rb ) )  }
+  end
+
+end  # module SOCMaker
+
+SOCMaker.require_all_libs
+
+# vim: noai:ts=2:sw=2

data/lib/soc_maker/cli.rb

@@ -0,0 +1,544 @@
+#!/usr/bin/env ruby
+###############################################################
+#   
+#  File:      cli.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 <http://www.gnu.org/licenses/>.
+#
+#
+###############################################################
+require 'readline'
+require 'optparse'
+require 'singleton'
+
+module SOCMaker
+
+#
+# Command-line interface for accessing the SOC-Maker functionallity
+# 
+# PLEASE NOTE: this class is outdated and needs some work!!
+# 
+# The following commands are available:
+# - new           -> create a new soc file
+# - open          -> open soc file
+# - list          -> list library
+# - add           -> add core to the SOC
+# - add_interface -> add an interface to the SOC
+# - parameter     -> set/get parameter
+# - sparameter    -> set/get static parameter
+# - connect       -> connect cores
+# - delete        -> delete core or connection
+# - save          -> save soc
+# - generate      -> generate soc
+# - quit          -> quit this CLI
+# - exit          -> same than quit
+# - help          -> print some help
+# 
+# Please use the help command to get more information about
+# each command and its parameters.
+# 
+# This CLI is a wrapper around SOCMaker::SOCDef and
+# this class is realized as singleton.
+#
+# TODO: add commands for
+# - selecting the coder (at the moment, only VHDL is supported)
+# - refreshing the lib
+#
+class Cli
+
+  # to organize it as singleton
+  #
+  include Singleton
+
+
+  #
+  # the SOC, which is edited by this script
+  # 
+  @soc      = nil
+
+
+  #
+  # An abbreviation map.
+  #
+  @appr_map = {}
+
+
+  #
+  # All available commands
+  #
+  @commands = []
+
+  # 
+  # Constructor of this CLI: it sets up a abbreviation map and a list
+  # of available commands. Moreover, it initializes readline.
+  #
+  def initialize
+
+    # abbreviation map
+    @appr_map = { 'n' => "new",
+                  'o' => "open",
+                  'q' => "quit",
+                  'h' => "help",
+                  'l' => "list", 
+                  'a' => "add",
+                  'g' => "generate",
+                  's' => "save",
+                  'p' => "parameter",
+                  'd' => "delete",
+                  'c' => "connect",
+                  'i' => "print",
+                  'x' => "exit"
+                  }
+
+    # all available commands
+    @commands = %w[ new open list add add_interface parameter sparameter  
+                    delete connect save help quit exit 
+                    generate print set get ]
+
+    comp = proc { |s| (@commands + Dir.entries( Dir.pwd )).grep( /^#{Regexp.escape(s)}/ ) }
+    Readline.completion_append_character = " "
+    Readline.completion_proc = comp
+
+  end
+
+  #
+  # Method to start processing the commands. Readline us used
+  # to receive input data. Each line to passed to process_cmd.
+  #
+  def run
+
+    ##
+    # process user commands
+    #
+    while buf = Readline.readline( "> ", true )
+      process_cmd buf
+    end
+  end
+
+  #
+  # Method to processes a single command
+  #
+  def process_cmd( c )
+
+      # remove the comments and split each line
+      match = SOCMaker::conf[ :COMMENT_REGEX ].match( c )
+      cmd_arr = match[1].split( ' ' )
+
+      # process the command, if there is one
+      if cmd_arr.size > 0 
+        cmd     = ""
+        if cmd_arr[ 0 ].size == 1 and @appr_map[ cmd_arr[ 0 ] ] != nil
+          cmd = @appr_map[ cmd_arr[ 0 ] ] 
+        else
+          cmd = cmd_arr[ 0 ] 
+        end
+
+        if @commands.include?( cmd )
+          cmd_str = "do_#{cmd}( cmd_arr[ 1..-1] )"  
+          puts "evaluating >>#{cmd_str}<< "
+          eval( cmd_str ) 
+        elsif !Gem.win_platform? && system( "which #{cmd} > /dev/null 2>&1" )
+          # this is for linux only
+          system( c )
+        else
+          puts "Command #{cmd} not available"
+        end
+       #begin
+       #rescue 
+       #  puts "evaluating >>#{cmd_str}<< failed"
+       #end
+      end
+  end
+
+
+private
+
+
+  # failed message
+  FMSG      = ' -> failed '
+
+
+  #########################################
+  #
+  # command implementations:
+  #   -> a usage string and
+  #      a function for every command
+  #
+
+  #
+  # Usage message of the 'new' comand
+  #
+  NEW_USAGE = 
+  "  > new <<name>> <<id>> <<toplevel>>   # opens a system-on-chip file
+         - <<name>>     : the SOC name
+         - <<id>>       : the SOC id
+         - <<toplevel>> : the toplevel name
+  "
+
+  #
+  # Implementation of the 'new' command
+  #
+  def do_new( args )
+    if args.size != 3
+      puts "three arguments are required:\nusage:\n#{NEW_USAGE}"
+    else
+      @soc = SOCMaker::SOCDef.new( args[0], args[1], args[2] ) 
+      SOCMaker::lib.add_core( @soc )
+      @soc.consistence_check
+    end
+  end
+
+  #
+  # Usage message of the 'open' comand
+  #
+  OPEN_USAGE =
+  "  > open <<file>>    # opens a system-on-chip file
+         - <<file>>    : system-on-chip definition in in YAML format
+
+  "
+  #
+  # Implementation of the 'open' command
+  #
+  def do_open( args )
+    if args.size != 1
+      puts "only one argument is required:\nusage:\n#{OPEN_USAGE}"
+    else
+      puts "loading #{args[0]}"
+      @soc = SOCMaker::from_f( args[0] ) 
+      SOCMaker::lib.add_core( @soc )
+      @soc.consistence_check
+    end
+  end
+
+  #
+  # Usage message of the 'list' comand
+  #
+  LIST_USAGE = 
+  "  > list             # prints list of cores and interfaces,
+                          which are in the library
+
+  "
+  #
+  # Implementation of the 'list' command
+  #
+  def do_list( args )
+    puts SOCMaker::lib
+  end
+
+  #
+  # Usage message of the 'add' comand
+  #
+  ADD_USAGE = 
+  "  > add <<id>> <<name>>    
+                        # adds an ip-core from the library to the SOC
+        - <<id>>      : id of the IP core
+        - <<name>>    : instanciation name
+
+  "
+  #
+  # Implementation of the 'add' command
+  #
+  def do_add( args )
+    if args.size != 2
+      puts "two arguments are required:\nusage:\n#{ADD_USAGE}"
+    else
+      @soc.add_core( args[ 0 ].to_sym, args[ 1 ].to_sym ) 
+      @soc.consistence_check
+    end
+  end
+
+
+  ADD_INTERFACE_USAGE =
+  "  > add_interface  <<name>> <<id>> <<dir>> <<port_name>> <<port_size>> [ <<port_name>> <<port_size>> .... ]
+                        # adds an interface to the SOC
+        - <<name>>      name of the interface
+        - <<id>>        id of the interface specification
+        - <<dir>>       the direction
+        - <<port_name>> name of the port
+        - <<port_size>> size of the port
+
+  "
+  def do_add_interface( args )
+
+
+    if args.size < 5 || args.size % 2 != 1
+      puts "five or more (but odd) arguments required:\nusage:\n#{ADD_INTERFACE_USAGE}"
+    else
+      ports = {}
+      args[3..-1].each_slice(2).to_a.each do |entry| 
+        ports[ entry[0].to_sym ] = SOCMaker::IfcPort.new( entry[0], entry[1] )
+      end
+
+      @soc.add_interface( args[0], args[ 1 ], args[2].to_i, ports )
+
+    end
+
+  end
+
+  #
+  # Usage message of the 'parameter' comand
+  #
+  PARAMETER_USAGE = 
+  "  > prameter <<instance>> <<parameter>> <<value>>
+                        # modifies a parameter of an instance
+       - <<instance>>   : the instance name of the core
+       - <<parameter>>  : the instance parameter name 
+       - <<value>>      : the value which is set (optional). The current 
+                          value is printed, if omitted
+  "
+  #
+  # Implementation of the 'parameter' command
+  #
+  def do_parameter( args )
+    if args.size == 2 
+      @soc.get_param( args[ 0 ].to_sym, args[ 1 ].to_sym ) 
+    elsif args.size == 3
+      @soc.set_param( args[ 0 ].to_sym, args[ 1 ].to_sym, args[ 2 ] ) 
+      @soc.consistence_check
+    else
+      puts "two or three arguments required:\nusage:\n#{PARAMETER_USAGE}"
+    end
+  end
+
+  #
+  # Usage message of the 'sparameter' comand
+  #
+  SPARAMETER_USAGE = 
+  "  > sprameter <<core>> <<parameter>> <<value>>
+                        # modifies the static parameter of a core
+       - <<core>>       : the name of the core
+       - <<parameter>>  : the static parameter name 
+       - <<value>>      : the value which is set (optional). The current 
+                          value is printed, if omitted
+  "
+  #
+  # Implementation of the 'sparameter' command
+  #
+  def do_sparameter( args )
+    if args.size == 2 
+      @soc.get_sparam( args[ 0 ].to_sym, args[ 1 ].to_sym )
+    elsif args.size == 3
+      @soc.set_sparam( args[ 0 ].to_sym, args[ 1 ].to_sym, args[ 2 ] ) 
+      @soc.consistence_check
+    else
+      puts "two or three arguments required:\nusage:\n#{SPARAMETER_USAGE}"
+    end
+  end
+
+  #
+  # Usage message of the 'connect' comand
+  #
+  CONNECT_USAGE = 
+  "  > connect <<name>> <<core1>> <<ifc1>> <<core2>> <<ifc2>> 
+                        # connects two cores
+        - <<name>>      : connection name
+        - <<core1>>     : instance name of the first core
+        - <<core2>>     : instance name of the second core
+        - <<ifc1>>      : interface name of the first core
+        - <<ifc2>>      : interface name of the second core
+
+  "      
+  #
+  # Implementation of the 'connect' command
+  #
+  def do_connect( args )
+    if args.size != 5
+      puts "five arguments are required:\nusage:\n#{CONNECT_USAGE}"
+    else
+      @soc.add_connection( args[ 0 ], 
+                           args[ 1 ].to_sym, 
+                           args[ 2 ].to_sym, 
+                           args[ 3 ].to_sym, 
+                                        args[ 4 ].to_sym )
+      @soc.consistence_check
+    end
+  end
+
+  #
+  # Usage message of the 'delete' comand
+  #
+  DELETE_USAGE = 
+  "  > delete <<core/connection>>
+                        # removes a core or a connection
+        - <<core/conection> : the core or connection, which is removed
+
+  "
+  #
+  # Implementation of the 'delete' command
+  #
+  def do_delete( args )
+    if args.size != 1 
+      puts "five arguments are required:\nusage:\n#{DELETE_USAGE}"
+    else
+      @soc.rm( args[ 0 ].to_sym ) 
+      @soc.consistence_check
+    end
+  end
+  #
+  # Usage message of the 'save' comand
+  #
+  SAVE_USAGE = 
+  "  > save <<file>>    # saves system-on-chip definition in YAML format to file
+        - <<file>>     : optional destination file, when omitted: the 
+                         original file-path is used
+
+  "
+  #
+  # Implementation of the 'save' command
+  #
+  def do_save( args )
+    if args.size > 1
+      puts "zero or one argument is required:\nusage:\n#{SAVE_USAGE}"
+    else
+      p args
+      @soc.save_yaml( args ) 
+      File.open( args[0], 'w' ) { |f| f.write( SOCMaker::to_yaml_s( @soc )  ) }
+    end
+  end
+
+  #
+  # Usage message of the 'generate' comand
+  #
+  GENERATE_USAGE = 
+  "  > generate         # generates a synthesizable system-on-chip implementation
+
+  "
+  #
+  # Implementation of the 'generate' command
+  #
+  def do_generate( args )
+    if args.size != 0
+      puts "no arguments are required:\nusage:\n#{GENERATE_USAGE}"
+    else
+      @soc.consistence_check
+      SOCMaker::deploy_soc( @soc )
+    end
+  end
+
+  #
+  # Usage message of the 'print' comand
+  #
+  PRINT_USAGE = 
+  "  > print            # prints SOC information
+
+  "
+  #
+  # Implementation of the 'print' command
+  #
+  def do_print( args )
+    if args.size != 0
+      puts "no arguments are required:\nusage:\n#{PRINT_USAGE}"
+    else
+      puts @soc
+    end
+  end
+
+  #
+  # Usage message of the 'quit' comand
+  #
+  QUIT_USAGE = 
+  "  > quit             # the same than exit
+
+  "
+  #
+  # Implementation of the 'quit' command
+  #
+  def do_quit( args )
+    do_exit( args )
+  end
+
+  #
+  # Usage message of the 'exit' comand
+  #
+  EXIT_USAGE = 
+  "  > exit             # exits this tool
+
+  "
+  #
+  # Implementation of the 'exit' command
+  #
+  def do_exit( args )
+    puts "... bye bye!"
+    exit 0
+  end
+
+  #
+  # Usage message of the 'help' comand
+  #
+  HELP_USAGE = 
+  "  > help             # prints some help information
+
+  "
+  #
+  # Implementation of the 'help' command
+  #
+  def do_help( args )
+    puts "The following commands are available:\n\n"
+    @commands.each { |c| eval "puts  #{c.upcase}_USAGE" }
+  end
+
+  #
+  # Usage message of the 'set' comand
+  #
+  SET_USAGE = 
+  "  > set              # not implemented yet
+
+  "
+  #
+  # Implementation of the 'set' command
+  #
+  def do_set( args )
+    puts "NOT IMPLEMENTED, YET"
+  end
+  #
+  # Usage message of the 'get' comand
+  #
+  GET_USAGE = 
+  "  > get              # not implemented yet
+
+  "
+  #
+  # Implementation of the 'get' command
+  #
+  def do_get( args )
+    puts "NOT IMPLEMENTED, YET"
+  end
+
+  #  end command implementations
+  #
+  #################################
+
+
+
+
+end
+end
+
+
+# vim: noai:ts=2:sw=2
+