class Tdl

read sdlmodule head

second load lib

require_relative “./bfm/bfm_lib” ## test require_relative “./exlib/common_cfg_reg_inf”

require_relative “./exlib/integral_test/integral_test” test require_relative './exlib/integral_test/clock_itest' test require_path_and_ignore(File.join(__dir__,'exlibintegral_test'),File.join(__dir__,'exlibintegral_testauto')) test require_relative “./exlib/common_cfg_reg_inf”

Public Class Methods

Axi4Path() click to toggle source
# File lib/tdl/tdl.rb, line 152
def self.Axi4Path
    @@Axi4Path
end
Axi4Path=(a) click to toggle source
# File lib/tdl/tdl.rb, line 156
def self.Axi4Path=(a)
    TdlError.new("#{a.to_s} is not exist") unless File.exist? a
    @@Axi4Path = a
end
Build_SdlModule_Puts(args) click to toggle source
# File lib/tdl/tdl.rb, line 225
def self.Build_SdlModule_Puts(args)
    return unless @@puts_enable
    @@build_sdlmodule_collect << args
end
Build_TdlModule_Puts(args) click to toggle source
# File lib/tdl/tdl.rb, line 220
def self.Build_TdlModule_Puts(args)
    return unless @@puts_enable
    @@build_tdlmodule_collect << args
end
Puts(*args) click to toggle source
# File lib/tdl/tdl.rb, line 216
def self.Puts(*args)
    puts args if @@puts_enable
end
PutsEnable() click to toggle source
# File lib/tdl/tdl.rb, line 212
def self.PutsEnable
    @@puts_enable
end
PutsEnable=(a) click to toggle source
# File lib/tdl/tdl.rb, line 208
def self.PutsEnable=(a)
    @@puts_enable = a
end
add_to_all_file_paths(a,b) click to toggle source
# File lib/tdl/tdl.rb, line 173
def self.add_to_all_file_paths(a,b)

    unless b
        raise TdlError.new("FilePath Path[#{b}] can be nil")
    end

     @@all_file_paths ||= Hash.new
     if @@all_file_paths.keys.include? a
         if @@all_file_paths[a] != b
             raise TdlError.new("FilePath confuse, Module <<#{a}>> in tow paths <<#{@@all_file_paths[a]}>>,<<#{b}>>")
         end
     else
         @@all_file_paths[a] = b
     end

 end
all_file_paths() click to toggle source
# File lib/tdl/tdl.rb, line 190
def self.all_file_paths
    @@all_file_paths ||= Hash.new
end
comment(c="-",info="_____") click to toggle source
# File lib/tdl/tdl.rb, line 144
def self.comment(c="-",info="_____")
    "\n//#{c*4}>> #{info} <<#{c*40}\n"
end
head_logo=(a) click to toggle source
# File lib/tdl/sdlmodule/sdlmodule_draw.rb, line 8
def self.head_logo=(a) 
    $__sdlmodule_head_logo__ = a
    @@__head_logo__ = a
end
inst_axi4_combin_wr_rd_batch( wr_slaver:"wr_slaver", rd_slaver:"rd_slaver", master:"master") click to toggle source
# File lib/tdl/axi4/bak/axi4_combin_wr_rd_batch_auto.rb, line 95
def Tdl.inst_axi4_combin_wr_rd_batch(
    wr_slaver:"wr_slaver",
    rd_slaver:"rd_slaver",
    master:"master")
    hash = TdlHash.new
    
    unless wr_slaver.is_a? Hash
        hash.case_record(:wr_slaver,wr_slaver)
    else
        # hash.new_index(:wr_slaver)= lambda { a = Axi4.new(wr_slaver);a.name = "wr_slaver";return a }
        # hash[:wr_slaver] = lambda { a = Axi4.new(wr_slaver);a.name = "wr_slaver";return a }
        raise TdlError.new('axi4_combin_wr_rd_batch Axi4 wr_slaver TdlHash cant include Proc') if wr_slaver.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Axi4.new(wr_slaver)
            unless wr_slaver[:name]
                a.name = "wr_slaver"
            end
            return a }
        hash.[]=(:wr_slaver,lam,false)
    end
            

    unless rd_slaver.is_a? Hash
        hash.case_record(:rd_slaver,rd_slaver)
    else
        # hash.new_index(:rd_slaver)= lambda { a = Axi4.new(rd_slaver);a.name = "rd_slaver";return a }
        # hash[:rd_slaver] = lambda { a = Axi4.new(rd_slaver);a.name = "rd_slaver";return a }
        raise TdlError.new('axi4_combin_wr_rd_batch Axi4 rd_slaver TdlHash cant include Proc') if rd_slaver.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Axi4.new(rd_slaver)
            unless rd_slaver[:name]
                a.name = "rd_slaver"
            end
            return a }
        hash.[]=(:rd_slaver,lam,false)
    end
            

    unless master.is_a? Hash
        hash.case_record(:master,master)
    else
        # hash.new_index(:master)= lambda { a = Axi4.new(master);a.name = "master";return a }
        # hash[:master] = lambda { a = Axi4.new(master);a.name = "master";return a }
        raise TdlError.new('axi4_combin_wr_rd_batch Axi4 master TdlHash cant include Proc') if master.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Axi4.new(master)
            unless master[:name]
                a.name = "master"
            end
            return a }
        hash.[]=(:master,lam,false)
    end
            

    hash.push_to_module_stack(Axi4,:axi4_combin_wr_rd_batch)
    hash.open_error = true
    return hash
end
inst_axi4_direct( mode:"BOTH_to_BOTH", slaver:"slaver", master:"master") click to toggle source
# File lib/tdl/axi4/bak/axi4_direct_auto.rb, line 95
def Tdl.inst_axi4_direct(
    mode:"BOTH_to_BOTH",
    slaver:"slaver",
    master:"master")
    hash = TdlHash.new
    
    unless mode.is_a? Hash
        hash.case_record(:mode,mode)
    else
        # hash.new_index(:mode)= lambda { a = Parameter.new(mode);a.name = "mode";return a }
        # hash[:mode] = lambda { a = Parameter.new(mode);a.name = "mode";return a }
        raise TdlError.new('axi4_direct Parameter mode TdlHash cant include Proc') if mode.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(mode)
            unless mode[:name]
                a.name = "mode"
            end
            return a }
        hash.[]=(:mode,lam,false)
    end
            

    unless slaver.is_a? Hash
        hash.case_record(:slaver,slaver)
    else
        # hash.new_index(:slaver)= lambda { a = Axi4.new(slaver);a.name = "slaver";return a }
        # hash[:slaver] = lambda { a = Axi4.new(slaver);a.name = "slaver";return a }
        raise TdlError.new('axi4_direct Axi4 slaver TdlHash cant include Proc') if slaver.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Axi4.new(slaver)
            unless slaver[:name]
                a.name = "slaver"
            end
            return a }
        hash.[]=(:slaver,lam,false)
    end
            

    unless master.is_a? Hash
        hash.case_record(:master,master)
    else
        # hash.new_index(:master)= lambda { a = Axi4.new(master);a.name = "master";return a }
        # hash[:master] = lambda { a = Axi4.new(master);a.name = "master";return a }
        raise TdlError.new('axi4_direct Axi4 master TdlHash cant include Proc') if master.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Axi4.new(master)
            unless master[:name]
                a.name = "master"
            end
            return a }
        hash.[]=(:master,lam,false)
    end
            

    hash.push_to_module_stack(Axi4,:axi4_direct)
    hash.open_error = true
    return hash
end
inst_axi4_direct_verb( slaver:"slaver", master:"master") click to toggle source
# File lib/tdl/axi4/bak/axi4_direct_verb_auto.rb, line 85
def Tdl.inst_axi4_direct_verb(
    slaver:"slaver",
    master:"master")
    hash = TdlHash.new
    
    unless slaver.is_a? Hash
        hash.case_record(:slaver,slaver)
    else
        # hash.new_index(:slaver)= lambda { a = Axi4.new(slaver);a.name = "slaver";return a }
        # hash[:slaver] = lambda { a = Axi4.new(slaver);a.name = "slaver";return a }
        raise TdlError.new('axi4_direct_verb Axi4 slaver TdlHash cant include Proc') if slaver.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Axi4.new(slaver)
            unless slaver[:name]
                a.name = "slaver"
            end
            return a }
        hash.[]=(:slaver,lam,false)
    end
            

    unless master.is_a? Hash
        hash.case_record(:master,master)
    else
        # hash.new_index(:master)= lambda { a = Axi4.new(master);a.name = "master";return a }
        # hash[:master] = lambda { a = Axi4.new(master);a.name = "master";return a }
        raise TdlError.new('axi4_direct_verb Axi4 master TdlHash cant include Proc') if master.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Axi4.new(master)
            unless master[:name]
                a.name = "master"
            end
            return a }
        hash.[]=(:master,lam,false)
    end
            

    hash.push_to_module_stack(Axi4,:axi4_direct_verb)
    hash.open_error = true
    return hash
end
inst_axi4_long_to_axi4_wide( slaver:"slaver", master:"master") click to toggle source
# File lib/tdl/axi4/bak/axi4_long_to_axi4_wide_auto.rb, line 85
def Tdl.inst_axi4_long_to_axi4_wide(
    slaver:"slaver",
    master:"master")
    hash = TdlHash.new
    
    unless slaver.is_a? Hash
        hash.case_record(:slaver,slaver)
    else
        # hash.new_index(:slaver)= lambda { a = Axi4.new(slaver);a.name = "slaver";return a }
        # hash[:slaver] = lambda { a = Axi4.new(slaver);a.name = "slaver";return a }
        raise TdlError.new('axi4_long_to_axi4_wide Axi4 slaver TdlHash cant include Proc') if slaver.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Axi4.new(slaver)
            unless slaver[:name]
                a.name = "slaver"
            end
            return a }
        hash.[]=(:slaver,lam,false)
    end
            

    unless master.is_a? Hash
        hash.case_record(:master,master)
    else
        # hash.new_index(:master)= lambda { a = Axi4.new(master);a.name = "master";return a }
        # hash[:master] = lambda { a = Axi4.new(master);a.name = "master";return a }
        raise TdlError.new('axi4_long_to_axi4_wide Axi4 master TdlHash cant include Proc') if master.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Axi4.new(master)
            unless master[:name]
                a.name = "master"
            end
            return a }
        hash.[]=(:master,lam,false)
    end
            

    hash.push_to_module_stack(Axi4,:axi4_long_to_axi4_wide)
    hash.open_error = true
    return hash
end
inst_axi4_long_to_axi4_wide_a1( partition:"ON", slaver:"slaver", master:"master") click to toggle source
# File lib/tdl/axi4/bak/axi4_long_to_axi4_wide_A1_auto.rb, line 95
def Tdl.inst_axi4_long_to_axi4_wide_a1(
    partition:"ON",
    slaver:"slaver",
    master:"master")
    hash = TdlHash.new
    
    unless partition.is_a? Hash
        hash.case_record(:partition,partition)
    else
        # hash.new_index(:partition)= lambda { a = Parameter.new(partition);a.name = "partition";return a }
        # hash[:partition] = lambda { a = Parameter.new(partition);a.name = "partition";return a }
        raise TdlError.new('axi4_long_to_axi4_wide_a1 Parameter partition TdlHash cant include Proc') if partition.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(partition)
            unless partition[:name]
                a.name = "partition"
            end
            return a }
        hash.[]=(:partition,lam,false)
    end
            

    unless slaver.is_a? Hash
        hash.case_record(:slaver,slaver)
    else
        # hash.new_index(:slaver)= lambda { a = Axi4.new(slaver);a.name = "slaver";return a }
        # hash[:slaver] = lambda { a = Axi4.new(slaver);a.name = "slaver";return a }
        raise TdlError.new('axi4_long_to_axi4_wide_a1 Axi4 slaver TdlHash cant include Proc') if slaver.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Axi4.new(slaver)
            unless slaver[:name]
                a.name = "slaver"
            end
            return a }
        hash.[]=(:slaver,lam,false)
    end
            

    unless master.is_a? Hash
        hash.case_record(:master,master)
    else
        # hash.new_index(:master)= lambda { a = Axi4.new(master);a.name = "master";return a }
        # hash[:master] = lambda { a = Axi4.new(master);a.name = "master";return a }
        raise TdlError.new('axi4_long_to_axi4_wide_a1 Axi4 master TdlHash cant include Proc') if master.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Axi4.new(master)
            unless master[:name]
                a.name = "master"
            end
            return a }
        hash.[]=(:master,lam,false)
    end
            

    hash.push_to_module_stack(Axi4,:axi4_long_to_axi4_wide_a1)
    hash.open_error = true
    return hash
end
inst_axi4_long_to_axi4_wide_verb( pipe:"OFF", partition:"ON", slaver:"slaver", master:"master") click to toggle source
# File lib/tdl/axi4/bak/axi4_long_to_axi4_wide_verb_auto.rb, line 104
def Tdl.inst_axi4_long_to_axi4_wide_verb(
    pipe:"OFF",
    partition:"ON",
    slaver:"slaver",
    master:"master")
    hash = TdlHash.new
    
    unless pipe.is_a? Hash
        hash.case_record(:pipe,pipe)
    else
        # hash.new_index(:pipe)= lambda { a = Parameter.new(pipe);a.name = "pipe";return a }
        # hash[:pipe] = lambda { a = Parameter.new(pipe);a.name = "pipe";return a }
        raise TdlError.new('axi4_long_to_axi4_wide_verb Parameter pipe TdlHash cant include Proc') if pipe.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(pipe)
            unless pipe[:name]
                a.name = "pipe"
            end
            return a }
        hash.[]=(:pipe,lam,false)
    end
            

    unless partition.is_a? Hash
        hash.case_record(:partition,partition)
    else
        # hash.new_index(:partition)= lambda { a = Parameter.new(partition);a.name = "partition";return a }
        # hash[:partition] = lambda { a = Parameter.new(partition);a.name = "partition";return a }
        raise TdlError.new('axi4_long_to_axi4_wide_verb Parameter partition TdlHash cant include Proc') if partition.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(partition)
            unless partition[:name]
                a.name = "partition"
            end
            return a }
        hash.[]=(:partition,lam,false)
    end
            

    unless slaver.is_a? Hash
        hash.case_record(:slaver,slaver)
    else
        # hash.new_index(:slaver)= lambda { a = Axi4.new(slaver);a.name = "slaver";return a }
        # hash[:slaver] = lambda { a = Axi4.new(slaver);a.name = "slaver";return a }
        raise TdlError.new('axi4_long_to_axi4_wide_verb Axi4 slaver TdlHash cant include Proc') if slaver.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Axi4.new(slaver)
            unless slaver[:name]
                a.name = "slaver"
            end
            return a }
        hash.[]=(:slaver,lam,false)
    end
            

    unless master.is_a? Hash
        hash.case_record(:master,master)
    else
        # hash.new_index(:master)= lambda { a = Axi4.new(master);a.name = "master";return a }
        # hash[:master] = lambda { a = Axi4.new(master);a.name = "master";return a }
        raise TdlError.new('axi4_long_to_axi4_wide_verb Axi4 master TdlHash cant include Proc') if master.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Axi4.new(master)
            unless master[:name]
                a.name = "master"
            end
            return a }
        hash.[]=(:master,lam,false)
    end
            

    hash.push_to_module_stack(Axi4,:axi4_long_to_axi4_wide_verb)
    hash.open_error = true
    return hash
end
inst_axi4_packet_fifo( pipe:"OFF", depth:4, mode:"BOTH", axi_in:"axi_in", axi_out:"axi_out") click to toggle source
# File lib/tdl/axi4/bak/axi4_packet_fifo_auto.rb, line 167
def Tdl.inst_axi4_packet_fifo(
    pipe:"OFF",
    depth:4,
    mode:"BOTH",
    axi_in:"axi_in",
    axi_out:"axi_out")
    hash = TdlHash.new
    
    unless pipe.is_a? Hash
        hash.case_record(:pipe,pipe)
    else
        # hash.new_index(:pipe)= lambda { a = Parameter.new(pipe);a.name = "pipe";return a }
        # hash[:pipe] = lambda { a = Parameter.new(pipe);a.name = "pipe";return a }
        raise TdlError.new('axi4_packet_fifo Parameter pipe TdlHash cant include Proc') if pipe.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(pipe)
            unless pipe[:name]
                a.name = "pipe"
            end
            return a }
        hash.[]=(:pipe,lam,false)
    end
            

    unless depth.is_a? Hash
        hash.case_record(:depth,depth)
    else
        # hash.new_index(:depth)= lambda { a = Parameter.new(depth);a.name = "depth";return a }
        # hash[:depth] = lambda { a = Parameter.new(depth);a.name = "depth";return a }
        raise TdlError.new('axi4_packet_fifo Parameter depth TdlHash cant include Proc') if depth.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(depth)
            unless depth[:name]
                a.name = "depth"
            end
            return a }
        hash.[]=(:depth,lam,false)
    end
            

    unless mode.is_a? Hash
        hash.case_record(:mode,mode)
    else
        # hash.new_index(:mode)= lambda { a = Parameter.new(mode);a.name = "mode";return a }
        # hash[:mode] = lambda { a = Parameter.new(mode);a.name = "mode";return a }
        raise TdlError.new('axi4_packet_fifo Parameter mode TdlHash cant include Proc') if mode.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(mode)
            unless mode[:name]
                a.name = "mode"
            end
            return a }
        hash.[]=(:mode,lam,false)
    end
            

    unless axi_in.is_a? Hash
        hash.case_record(:axi_in,axi_in)
    else
        # hash.new_index(:axi_in)= lambda { a = Axi4.new(axi_in);a.name = "axi_in";return a }
        # hash[:axi_in] = lambda { a = Axi4.new(axi_in);a.name = "axi_in";return a }
        raise TdlError.new('axi4_packet_fifo Axi4 axi_in TdlHash cant include Proc') if axi_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Axi4.new(axi_in)
            unless axi_in[:name]
                a.name = "axi_in"
            end
            return a }
        hash.[]=(:axi_in,lam,false)
    end
            

    unless axi_out.is_a? Hash
        hash.case_record(:axi_out,axi_out)
    else
        # hash.new_index(:axi_out)= lambda { a = Axi4.new(axi_out);a.name = "axi_out";return a }
        # hash[:axi_out] = lambda { a = Axi4.new(axi_out);a.name = "axi_out";return a }
        raise TdlError.new('axi4_packet_fifo Axi4 axi_out TdlHash cant include Proc') if axi_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Axi4.new(axi_out)
            unless axi_out[:name]
                a.name = "axi_out"
            end
            return a }
        hash.[]=(:axi_out,lam,false)
    end
            

    hash.push_to_module_stack(Axi4,:axi4_packet_fifo)
    hash.open_error = true
    return hash
end
inst_axi4_pipe( slaver:"slaver", master:"master") click to toggle source
# File lib/tdl/axi4/bak/axi4_pipe_auto.rb, line 133
def Tdl.inst_axi4_pipe(
    slaver:"slaver",
    master:"master")
    hash = TdlHash.new
    
    unless slaver.is_a? Hash
        hash.case_record(:slaver,slaver)
    else
        # hash.new_index(:slaver)= lambda { a = Axi4.new(slaver);a.name = "slaver";return a }
        # hash[:slaver] = lambda { a = Axi4.new(slaver);a.name = "slaver";return a }
        raise TdlError.new('axi4_pipe Axi4 slaver TdlHash cant include Proc') if slaver.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Axi4.new(slaver)
            unless slaver[:name]
                a.name = "slaver"
            end
            return a }
        hash.[]=(:slaver,lam,false)
    end
            

    unless master.is_a? Hash
        hash.case_record(:master,master)
    else
        # hash.new_index(:master)= lambda { a = Axi4.new(master);a.name = "master";return a }
        # hash[:master] = lambda { a = Axi4.new(master);a.name = "master";return a }
        raise TdlError.new('axi4_pipe Axi4 master TdlHash cant include Proc') if master.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Axi4.new(master)
            unless master[:name]
                a.name = "master"
            end
            return a }
        hash.[]=(:master,lam,false)
    end
            

    hash.push_to_module_stack(Axi4,:axi4_pipe)
    hash.open_error = true
    return hash
end
inst_axi4_to_native_for_ddr_ip_verb(addr_width:27,data_width:256,app_addr:"app_addr",app_cmd:"app_cmd",app_en:"app_en",app_wdf_data:"app_wdf_data",app_wdf_end:"app_wdf_end",app_wdf_mask:"app_wdf_mask",app_wdf_wren:"app_wdf_wren",app_rd_data:"app_rd_data",app_rd_data_end:"app_rd_data_end",app_rd_data_valid:"app_rd_data_valid",app_rdy:"app_rdy",app_wdf_rdy:"app_wdf_rdy",init_calib_complete:"init_calib_complete",axi_inf:"axi_inf") click to toggle source
# File lib/tdl/axi_stream/bak/axi4_to_native_for_ddr_ip_verb_auto.rb, line 90
def self.inst_axi4_to_native_for_ddr_ip_verb(addr_width:27,data_width:256,app_addr:"app_addr",app_cmd:"app_cmd",app_en:"app_en",app_wdf_data:"app_wdf_data",app_wdf_end:"app_wdf_end",app_wdf_mask:"app_wdf_mask",app_wdf_wren:"app_wdf_wren",app_rd_data:"app_rd_data",app_rd_data_end:"app_rd_data_end",app_rd_data_valid:"app_rd_data_valid",app_rdy:"app_rdy",app_wdf_rdy:"app_wdf_rdy",init_calib_complete:"init_calib_complete",axi_inf:"axi_inf")
    hash = TdlHash.new
    
    unless addr_width.is_a? Hash
        # hash.new_index(:addr_width) = addr_width
        if addr_width.is_a? InfElm
            hash.[]=(:addr_width,addr_width,true)
        else
            hash.[]=(:addr_width,addr_width,false)
        end
    else
        # hash.new_index(:addr_width)= lambda { a = Parameter.new(addr_width);a.name = "addr_width";return a }
        # hash[:addr_width] = lambda { a = Parameter.new(addr_width);a.name = "addr_width";return a }
        hash.[]=(:addr_width,lambda { a = Parameter.new(addr_width);a.name = "addr_width";return a },false)
    end
            

    unless data_width.is_a? Hash
        # hash.new_index(:data_width) = data_width
        if data_width.is_a? InfElm
            hash.[]=(:data_width,data_width,true)
        else
            hash.[]=(:data_width,data_width,false)
        end
    else
        # hash.new_index(:data_width)= lambda { a = Parameter.new(data_width);a.name = "data_width";return a }
        # hash[:data_width] = lambda { a = Parameter.new(data_width);a.name = "data_width";return a }
        hash.[]=(:data_width,lambda { a = Parameter.new(data_width);a.name = "data_width";return a },false)
    end
            

    unless app_addr.is_a? Hash
        # hash.new_index(:app_addr) = app_addr
        if app_addr.is_a? InfElm
            hash.[]=(:app_addr,app_addr,true)
        else
            hash.[]=(:app_addr,app_addr,false)
        end
    else
        # hash.new_index(:app_addr)= lambda { a = Logic.new(app_addr);a.name = "app_addr";return a }
        # hash[:app_addr] = lambda { a = Logic.new(app_addr);a.name = "app_addr";return a }
        hash.[]=(:app_addr,lambda { a = Logic.new(app_addr);a.name = "app_addr";return a },false)
    end
            

    unless app_cmd.is_a? Hash
        # hash.new_index(:app_cmd) = app_cmd
        if app_cmd.is_a? InfElm
            hash.[]=(:app_cmd,app_cmd,true)
        else
            hash.[]=(:app_cmd,app_cmd,false)
        end
    else
        # hash.new_index(:app_cmd)= lambda { a = Logic.new(app_cmd);a.name = "app_cmd";return a }
        # hash[:app_cmd] = lambda { a = Logic.new(app_cmd);a.name = "app_cmd";return a }
        hash.[]=(:app_cmd,lambda { a = Logic.new(app_cmd);a.name = "app_cmd";return a },false)
    end
            

    unless app_en.is_a? Hash
        # hash.new_index(:app_en) = app_en
        if app_en.is_a? InfElm
            hash.[]=(:app_en,app_en,true)
        else
            hash.[]=(:app_en,app_en,false)
        end
    else
        # hash.new_index(:app_en)= lambda { a = Logic.new(app_en);a.name = "app_en";return a }
        # hash[:app_en] = lambda { a = Logic.new(app_en);a.name = "app_en";return a }
        hash.[]=(:app_en,lambda { a = Logic.new(app_en);a.name = "app_en";return a },false)
    end
            

    unless app_wdf_data.is_a? Hash
        # hash.new_index(:app_wdf_data) = app_wdf_data
        if app_wdf_data.is_a? InfElm
            hash.[]=(:app_wdf_data,app_wdf_data,true)
        else
            hash.[]=(:app_wdf_data,app_wdf_data,false)
        end
    else
        # hash.new_index(:app_wdf_data)= lambda { a = Logic.new(app_wdf_data);a.name = "app_wdf_data";return a }
        # hash[:app_wdf_data] = lambda { a = Logic.new(app_wdf_data);a.name = "app_wdf_data";return a }
        hash.[]=(:app_wdf_data,lambda { a = Logic.new(app_wdf_data);a.name = "app_wdf_data";return a },false)
    end
            

    unless app_wdf_end.is_a? Hash
        # hash.new_index(:app_wdf_end) = app_wdf_end
        if app_wdf_end.is_a? InfElm
            hash.[]=(:app_wdf_end,app_wdf_end,true)
        else
            hash.[]=(:app_wdf_end,app_wdf_end,false)
        end
    else
        # hash.new_index(:app_wdf_end)= lambda { a = Logic.new(app_wdf_end);a.name = "app_wdf_end";return a }
        # hash[:app_wdf_end] = lambda { a = Logic.new(app_wdf_end);a.name = "app_wdf_end";return a }
        hash.[]=(:app_wdf_end,lambda { a = Logic.new(app_wdf_end);a.name = "app_wdf_end";return a },false)
    end
            

    unless app_wdf_mask.is_a? Hash
        # hash.new_index(:app_wdf_mask) = app_wdf_mask
        if app_wdf_mask.is_a? InfElm
            hash.[]=(:app_wdf_mask,app_wdf_mask,true)
        else
            hash.[]=(:app_wdf_mask,app_wdf_mask,false)
        end
    else
        # hash.new_index(:app_wdf_mask)= lambda { a = Logic.new(app_wdf_mask);a.name = "app_wdf_mask";return a }
        # hash[:app_wdf_mask] = lambda { a = Logic.new(app_wdf_mask);a.name = "app_wdf_mask";return a }
        hash.[]=(:app_wdf_mask,lambda { a = Logic.new(app_wdf_mask);a.name = "app_wdf_mask";return a },false)
    end
            

    unless app_wdf_wren.is_a? Hash
        # hash.new_index(:app_wdf_wren) = app_wdf_wren
        if app_wdf_wren.is_a? InfElm
            hash.[]=(:app_wdf_wren,app_wdf_wren,true)
        else
            hash.[]=(:app_wdf_wren,app_wdf_wren,false)
        end
    else
        # hash.new_index(:app_wdf_wren)= lambda { a = Logic.new(app_wdf_wren);a.name = "app_wdf_wren";return a }
        # hash[:app_wdf_wren] = lambda { a = Logic.new(app_wdf_wren);a.name = "app_wdf_wren";return a }
        hash.[]=(:app_wdf_wren,lambda { a = Logic.new(app_wdf_wren);a.name = "app_wdf_wren";return a },false)
    end
            

    unless app_rd_data.is_a? Hash
        # hash.new_index(:app_rd_data) = app_rd_data
        if app_rd_data.is_a? InfElm
            hash.[]=(:app_rd_data,app_rd_data,true)
        else
            hash.[]=(:app_rd_data,app_rd_data,false)
        end
    else
        # hash.new_index(:app_rd_data)= lambda { a = Logic.new(app_rd_data);a.name = "app_rd_data";return a }
        # hash[:app_rd_data] = lambda { a = Logic.new(app_rd_data);a.name = "app_rd_data";return a }
        hash.[]=(:app_rd_data,lambda { a = Logic.new(app_rd_data);a.name = "app_rd_data";return a },false)
    end
            

    unless app_rd_data_end.is_a? Hash
        # hash.new_index(:app_rd_data_end) = app_rd_data_end
        if app_rd_data_end.is_a? InfElm
            hash.[]=(:app_rd_data_end,app_rd_data_end,true)
        else
            hash.[]=(:app_rd_data_end,app_rd_data_end,false)
        end
    else
        # hash.new_index(:app_rd_data_end)= lambda { a = Logic.new(app_rd_data_end);a.name = "app_rd_data_end";return a }
        # hash[:app_rd_data_end] = lambda { a = Logic.new(app_rd_data_end);a.name = "app_rd_data_end";return a }
        hash.[]=(:app_rd_data_end,lambda { a = Logic.new(app_rd_data_end);a.name = "app_rd_data_end";return a },false)
    end
            

    unless app_rd_data_valid.is_a? Hash
        # hash.new_index(:app_rd_data_valid) = app_rd_data_valid
        if app_rd_data_valid.is_a? InfElm
            hash.[]=(:app_rd_data_valid,app_rd_data_valid,true)
        else
            hash.[]=(:app_rd_data_valid,app_rd_data_valid,false)
        end
    else
        # hash.new_index(:app_rd_data_valid)= lambda { a = Logic.new(app_rd_data_valid);a.name = "app_rd_data_valid";return a }
        # hash[:app_rd_data_valid] = lambda { a = Logic.new(app_rd_data_valid);a.name = "app_rd_data_valid";return a }
        hash.[]=(:app_rd_data_valid,lambda { a = Logic.new(app_rd_data_valid);a.name = "app_rd_data_valid";return a },false)
    end
            

    unless app_rdy.is_a? Hash
        # hash.new_index(:app_rdy) = app_rdy
        if app_rdy.is_a? InfElm
            hash.[]=(:app_rdy,app_rdy,true)
        else
            hash.[]=(:app_rdy,app_rdy,false)
        end
    else
        # hash.new_index(:app_rdy)= lambda { a = Logic.new(app_rdy);a.name = "app_rdy";return a }
        # hash[:app_rdy] = lambda { a = Logic.new(app_rdy);a.name = "app_rdy";return a }
        hash.[]=(:app_rdy,lambda { a = Logic.new(app_rdy);a.name = "app_rdy";return a },false)
    end
            

    unless app_wdf_rdy.is_a? Hash
        # hash.new_index(:app_wdf_rdy) = app_wdf_rdy
        if app_wdf_rdy.is_a? InfElm
            hash.[]=(:app_wdf_rdy,app_wdf_rdy,true)
        else
            hash.[]=(:app_wdf_rdy,app_wdf_rdy,false)
        end
    else
        # hash.new_index(:app_wdf_rdy)= lambda { a = Logic.new(app_wdf_rdy);a.name = "app_wdf_rdy";return a }
        # hash[:app_wdf_rdy] = lambda { a = Logic.new(app_wdf_rdy);a.name = "app_wdf_rdy";return a }
        hash.[]=(:app_wdf_rdy,lambda { a = Logic.new(app_wdf_rdy);a.name = "app_wdf_rdy";return a },false)
    end
            

    unless init_calib_complete.is_a? Hash
        # hash.new_index(:init_calib_complete) = init_calib_complete
        if init_calib_complete.is_a? InfElm
            hash.[]=(:init_calib_complete,init_calib_complete,true)
        else
            hash.[]=(:init_calib_complete,init_calib_complete,false)
        end
    else
        # hash.new_index(:init_calib_complete)= lambda { a = Logic.new(init_calib_complete);a.name = "init_calib_complete";return a }
        # hash[:init_calib_complete] = lambda { a = Logic.new(init_calib_complete);a.name = "init_calib_complete";return a }
        hash.[]=(:init_calib_complete,lambda { a = Logic.new(init_calib_complete);a.name = "init_calib_complete";return a },false)
    end
            

    unless axi_inf.is_a? Hash
        # hash.new_index(:axi_inf) = axi_inf
        if axi_inf.is_a? InfElm
            hash.[]=(:axi_inf,axi_inf,true)
        else
            hash.[]=(:axi_inf,axi_inf,false)
        end
    else
        # hash.new_index(:axi_inf)= lambda { a = Axi4.new(axi_inf);a.name = "axi_inf";return a }
        # hash[:axi_inf] = lambda { a = Axi4.new(axi_inf);a.name = "axi_inf";return a }
        hash.[]=(:axi_inf,lambda { a = Axi4.new(axi_inf);a.name = "axi_inf";return a },false)
    end
            

    Tdl.module_stack  << lambda {
        hash.each do |k,v|
            if v.is_a? Proc
                hash.[]=(k,v.call,false)
            elsif v.is_a? Array
                unless v.empty?
                    if v[0].is_a? Axi4
                        cm = v[0].copy(name:k,idsize:Math.log2(v.length).ceil+v[0].idsize)
                    else
                        cm = v[0].copy(name:k)
                    end
                    cm.<<(*v)
                    # hash[k] = cm
                    hash.[]=(k,cm)
                else
                    hash.[]=(k,nil,false)
                end
            else
                # hash[k] = v
            end
        end
        hash.check_use("axi4_to_native_for_ddr_ip_verb")
        Axi4.axi4_to_native_for_ddr_ip_verb(hash)
    }
    return hash
end
inst_axi4_wr_auxiliary_gen_without_resp( stream_en:"stream_en", id_add_len_in:"id_add_len_in", axi_wr_aux:"axi_wr_aux") click to toggle source
# File lib/tdl/axi4/bak/__axi4_wr_auxiliary_gen_without_resp.rb, line 70
def Tdl.inst_axi4_wr_auxiliary_gen_without_resp(
    stream_en:"stream_en",
    id_add_len_in:"id_add_len_in",
    axi_wr_aux:"axi_wr_aux")
    hash = TdlHash.new

    unless stream_en.is_a? Hash
        # hash.new_index(:stream_en) = stream_en
        if stream_en.is_a? BaseElm
            hash.[]=(:stream_en,stream_en,true);hash[:stream_en];
            # hash.[]=(:stream_en,stream_en,false)
        elsif stream_en.is_a? GlobalSignalProc
            hash.[]=(:stream_en,stream_en,true)
        else
            hash.[]=(:stream_en,stream_en,false)
        end
    else
        # hash.new_index(:stream_en)= lambda { a = Logic.new(stream_en);a.name = "stream_en";return a }
        # hash[:stream_en] = lambda { a = Logic.new(stream_en);a.name = "stream_en";return a }
        raise TdlError.new('axi4_wr_auxiliary_gen_without_resp Logic stream_en TdlHash cant include Proc') if stream_en.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(stream_en)
            unless stream_en[:name]
                a.name = "stream_en"
            end
            return a }
        hash.[]=(:stream_en,lam,false)
    end


    unless id_add_len_in.is_a? Hash
        # hash.new_index(:id_add_len_in) = id_add_len_in
        if id_add_len_in.is_a? BaseElm
            hash.[]=(:id_add_len_in,id_add_len_in,true);hash[:id_add_len_in];
            # hash.[]=(:id_add_len_in,id_add_len_in,false)
        elsif id_add_len_in.is_a? GlobalSignalProc
            hash.[]=(:id_add_len_in,id_add_len_in,true)
        else
            hash.[]=(:id_add_len_in,id_add_len_in,false)
        end
    else
        # hash.new_index(:id_add_len_in)= lambda { a = AxiStream.new(id_add_len_in);a.name = "id_add_len_in";return a }
        # hash[:id_add_len_in] = lambda { a = AxiStream.new(id_add_len_in);a.name = "id_add_len_in";return a }
        raise TdlError.new('axi4_wr_auxiliary_gen_without_resp AxiStream id_add_len_in TdlHash cant include Proc') if id_add_len_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(id_add_len_in)
            unless id_add_len_in[:name]
                a.name = "id_add_len_in"
            end
            return a }
        hash.[]=(:id_add_len_in,lam,false)
    end


    unless axi_wr_aux.is_a? Hash
        # hash.new_index(:axi_wr_aux) = axi_wr_aux
        if axi_wr_aux.is_a? BaseElm
            hash.[]=(:axi_wr_aux,axi_wr_aux,true);hash[:axi_wr_aux];
            # hash.[]=(:axi_wr_aux,axi_wr_aux,false)
        elsif axi_wr_aux.is_a? GlobalSignalProc
            hash.[]=(:axi_wr_aux,axi_wr_aux,true)
        else
            hash.[]=(:axi_wr_aux,axi_wr_aux,false)
        end
    else
        # hash.new_index(:axi_wr_aux)= lambda { a = Axi4.new(axi_wr_aux);a.name = "axi_wr_aux";return a }
        # hash[:axi_wr_aux] = lambda { a = Axi4.new(axi_wr_aux);a.name = "axi_wr_aux";return a }
        raise TdlError.new('axi4_wr_auxiliary_gen_without_resp Axi4 axi_wr_aux TdlHash cant include Proc') if axi_wr_aux.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Axi4.new(axi_wr_aux)
            unless axi_wr_aux[:name]
                a.name = "axi_wr_aux"
            end
            return a }
        hash.[]=(:axi_wr_aux,lam,false)
    end


    Tdl.module_stack  << lambda {
        hash.each do |k,v|
            if v.is_a? Proc
                hash.[]=(k,v.call,false)
            elsif v.is_a? Array
            #    unless v.empty?
            #        if v[0].is_a? Axi4
            #            cm = v[0].copy(name:k,idsize:Math.log2(v.length).ceil+v[0].idsize)
            #        else
            #            cm = v[0].copy(name:k)
            #        end
            #        cm.<<(*v)
            #        # hash[k] = cm
            #        hash.[]=(k,cm)
            #    else
            #        hash.[]=(k,nil,false)
            #    end
            else
                # hash[k] = v
            end
        end
        hash.check_use("axi4_wr_auxiliary_gen_without_resp")
        AxiStream.axi4_wr_auxiliary_gen_without_resp(hash)
    }
    hash.open_error = true
    return hash
end
inst_axi_lite_master_empty( lite:"lite") click to toggle source
# File lib/tdl/axi_lite/bak/axi_lite_master_empty_auto.rb, line 71
def Tdl.inst_axi_lite_master_empty(
    lite:"lite")
    hash = TdlHash.new
    
    unless lite.is_a? Hash
        hash.case_record(:lite,lite)
    else
        # hash.new_index(:lite)= lambda { a = AxiLite.new(lite);a.name = "lite";return a }
        # hash[:lite] = lambda { a = AxiLite.new(lite);a.name = "lite";return a }
        raise TdlError.new('axi_lite_master_empty AxiLite lite TdlHash cant include Proc') if lite.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiLite.new(lite)
            unless lite[:name]
                a.name = "lite"
            end
            return a }
        hash.[]=(:lite,lam,false)
    end
            

    hash.push_to_module_stack(AxiLite,:axi_lite_master_empty)
    hash.open_error = true
    return hash
end
inst_axi_lite_slaver_empty( lite:"lite") click to toggle source
# File lib/tdl/axi_lite/bak/axi_lite_slaver_empty_auto.rb, line 64
def Tdl.inst_axi_lite_slaver_empty(
    lite:"lite")
    hash = TdlHash.new
    
    unless lite.is_a? Hash
        hash.case_record(:lite,lite)
    else
        # hash.new_index(:lite)= lambda { a = AxiLite.new(lite);a.name = "lite";return a }
        # hash[:lite] = lambda { a = AxiLite.new(lite);a.name = "lite";return a }
        raise TdlError.new('axi_lite_slaver_empty AxiLite lite TdlHash cant include Proc') if lite.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiLite.new(lite)
            unless lite[:name]
                a.name = "lite"
            end
            return a }
        hash.[]=(:lite,lam,false)
    end
            

    hash.push_to_module_stack(AxiLite,:axi_lite_slaver_empty)
    hash.open_error = true
    return hash
end
inst_axi_stream_cache( axis_in:"axis_in", axis_out:"axis_out") click to toggle source
# File lib/tdl/axi_stream/bak/axi_stream_cache_auto.rb, line 97
def Tdl.inst_axi_stream_cache(
    axis_in:"axis_in",
    axis_out:"axis_out")
    hash = TdlHash.new
    
    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('axi_stream_cache AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    unless axis_out.is_a? Hash
        hash.case_record(:axis_out,axis_out)
    else
        # hash.new_index(:axis_out)= lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        # hash[:axis_out] = lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        raise TdlError.new('axi_stream_cache AxiStream axis_out TdlHash cant include Proc') if axis_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_out)
            unless axis_out[:name]
                a.name = "axis_out"
            end
            return a }
        hash.[]=(:axis_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axi_stream_cache)
    hash.open_error = true
    return hash
end
inst_axi_stream_cache_35bit( axis_in:"axis_in", axis_out:"axis_out") click to toggle source
# File lib/tdl/axi_stream/bak/axi_stream_cache_35bit_auto.rb, line 97
def Tdl.inst_axi_stream_cache_35bit(
    axis_in:"axis_in",
    axis_out:"axis_out")
    hash = TdlHash.new
    
    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('axi_stream_cache_35bit AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    unless axis_out.is_a? Hash
        hash.case_record(:axis_out,axis_out)
    else
        # hash.new_index(:axis_out)= lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        # hash[:axis_out] = lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        raise TdlError.new('axi_stream_cache_35bit AxiStream axis_out TdlHash cant include Proc') if axis_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_out)
            unless axis_out[:name]
                a.name = "axis_out"
            end
            return a }
        hash.[]=(:axis_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axi_stream_cache_35bit)
    hash.open_error = true
    return hash
end
inst_axi_stream_cache_72_95bit_with_keep( axis_in:"axis_in", axis_out:"axis_out") click to toggle source
# File lib/tdl/axi_stream/bak/axi_stream_cache_72_95bit_with_keep_auto.rb, line 97
def Tdl.inst_axi_stream_cache_72_95bit_with_keep(
    axis_in:"axis_in",
    axis_out:"axis_out")
    hash = TdlHash.new
    
    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('axi_stream_cache_72_95bit_with_keep AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    unless axis_out.is_a? Hash
        hash.case_record(:axis_out,axis_out)
    else
        # hash.new_index(:axis_out)= lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        # hash[:axis_out] = lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        raise TdlError.new('axi_stream_cache_72_95bit_with_keep AxiStream axis_out TdlHash cant include Proc') if axis_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_out)
            unless axis_out[:name]
                a.name = "axis_out"
            end
            return a }
        hash.[]=(:axis_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axi_stream_cache_72_95bit_with_keep)
    hash.open_error = true
    return hash
end
inst_axi_stream_cache_b1( axis_in:"axis_in", axis_out:"axis_out") click to toggle source
# File lib/tdl/axi_stream/bak/axi_stream_cache_B1_auto.rb, line 97
def Tdl.inst_axi_stream_cache_b1(
    axis_in:"axis_in",
    axis_out:"axis_out")
    hash = TdlHash.new
    
    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('axi_stream_cache_b1 AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    unless axis_out.is_a? Hash
        hash.case_record(:axis_out,axis_out)
    else
        # hash.new_index(:axis_out)= lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        # hash[:axis_out] = lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        raise TdlError.new('axi_stream_cache_b1 AxiStream axis_out TdlHash cant include Proc') if axis_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_out)
            unless axis_out[:name]
                a.name = "axis_out"
            end
            return a }
        hash.[]=(:axis_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axi_stream_cache_b1)
    hash.open_error = true
    return hash
end
inst_axi_stream_cache_mirror( axis_in:"axis_in", axis_out:"axis_out") click to toggle source
# File lib/tdl/axi_stream/bak/axi_stream_cache_mirror_auto.rb, line 97
def Tdl.inst_axi_stream_cache_mirror(
    axis_in:"axis_in",
    axis_out:"axis_out")
    hash = TdlHash.new
    
    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('axi_stream_cache_mirror AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    unless axis_out.is_a? Hash
        hash.case_record(:axis_out,axis_out)
    else
        # hash.new_index(:axis_out)= lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        # hash[:axis_out] = lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        raise TdlError.new('axi_stream_cache_mirror AxiStream axis_out TdlHash cant include Proc') if axis_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_out)
            unless axis_out[:name]
                a.name = "axis_out"
            end
            return a }
        hash.[]=(:axis_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axi_stream_cache_mirror)
    hash.open_error = true
    return hash
end
inst_axi_stream_cache_verb( axis_in:"axis_in", axis_out:"axis_out") click to toggle source
# File lib/tdl/axi_stream/bak/axi_stream_cache_verb_auto.rb, line 97
def Tdl.inst_axi_stream_cache_verb(
    axis_in:"axis_in",
    axis_out:"axis_out")
    hash = TdlHash.new
    
    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('axi_stream_cache_verb AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    unless axis_out.is_a? Hash
        hash.case_record(:axis_out,axis_out)
    else
        # hash.new_index(:axis_out)= lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        # hash[:axis_out] = lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        raise TdlError.new('axi_stream_cache_verb AxiStream axis_out TdlHash cant include Proc') if axis_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_out)
            unless axis_out[:name]
                a.name = "axis_out"
            end
            return a }
        hash.[]=(:axis_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axi_stream_cache_verb)
    hash.open_error = true
    return hash
end
inst_axi_stream_interconnect_s2m( num:8, addr:"addr", s00:"s00", m00:"m00") click to toggle source
# File lib/tdl/axi_stream/bak/__axi_stream_interconnect_S2M.rb, line 72
def Tdl.inst_axi_stream_interconnect_s2m(
    num:8,
    addr:"addr",
    s00:"s00",
    m00:"m00")
    hash = TdlHash.new

    unless num.is_a? Hash
        # hash.new_index(:num) = num
        if( (num.is_a? BaseElm) || (num.is_a? GlobalSignalProc))
            hash.[]=(:num,num,true)
        else
            hash.[]=(:num,num,false)
        end
    else
        # hash.new_index(:num)= lambda { a = Parameter.new(num);a.name = "num";return a }
        # hash[:num] = lambda { a = Parameter.new(num);a.name = "num";return a }
        lam = lambda {
            a = Parameter.new(num)
            unless num[:name]
                a.name = "num"
            end
            return a }
        hash.[]=(:num,lam,false)
    end


    unless addr.is_a? Hash
        # hash.new_index(:addr) = addr
        if( (addr.is_a? BaseElm) || (addr.is_a? GlobalSignalProc))
            hash.[]=(:addr,addr,true)
        else
            hash.[]=(:addr,addr,false)
        end
    else
        # hash.new_index(:addr)= lambda { a = Logic.new(addr);a.name = "addr";return a }
        # hash[:addr] = lambda { a = Logic.new(addr);a.name = "addr";return a }
        lam = lambda {
            a = Logic.new(addr)
            unless addr[:name]
                a.name = "addr"
            end
            return a }
        hash.[]=(:addr,lam,false)
    end


    unless s00.is_a? Hash
        # hash.new_index(:s00) = s00
        if( (s00.is_a? BaseElm) || (s00.is_a? GlobalSignalProc))
            hash.[]=(:s00,s00,true)
        else
            hash.[]=(:s00,s00,false)
        end
    else
        # hash.new_index(:s00)= lambda { a = AxiStream.new(s00);a.name = "s00";return a }
        # hash[:s00] = lambda { a = AxiStream.new(s00);a.name = "s00";return a }
        lam = lambda {
            a = AxiStream.new(s00)
            unless s00[:name]
                a.name = "s00"
            end
            return a }
        hash.[]=(:s00,lam,false)
    end


    unless m00.is_a? Hash
        # hash.new_index(:m00) = m00
        if( (m00.is_a? BaseElm) || (m00.is_a? GlobalSignalProc))
            hash.[]=(:m00,m00,true)
        else
            hash.[]=(:m00,m00,false)
        end
    else
        # hash.new_index(:m00)= lambda { a = AxiStream.new(m00);a.name = "m00";return a }
        # hash[:m00] = lambda { a = AxiStream.new(m00);a.name = "m00";return a }
        lam = lambda {
            a = AxiStream.new(m00)
            unless m00[:name]
                a.name = "m00"
            end
            return a }
        hash.[]=(:m00,lam,false)
    end


    Tdl.module_stack  << lambda {
        hash.each do |k,v|
            if v.is_a? Proc
                hash.[]=(k,v.call,false)
            elsif v.is_a? Array
            #    unless v.empty?
            #        if v[0].is_a? Axi4
            #            cm = v[0].copy(name:k,idsize:Math.log2(v.length).ceil+v[0].idsize)
            #        else
            #            cm = v[0].copy(name:k)
            #        end
            #        cm.<<(*v)
            #        # hash[k] = cm
            #        hash.[]=(k,cm)
            #    else
            #        hash.[]=(k,nil,false)
            #    end
            else
                # hash[k] = v
            end
        end
        hash.check_use("axi_stream_interconnect_s2m")
        AxiStream.axi_stream_interconnect_s2m(hash)
    }
    hash.open_error = true
    return hash
end
inst_axi_stream_interconnect_s2m_with_keep( num:8, nsize:"NUM <= 2? 1 :", addr:"addr", s00:"s00", m00:"m00") click to toggle source
# File lib/tdl/axi_stream/bak/axi_stream_interconnect_S2M_with_keep.sv_auto.rb, line 74
def Tdl.inst_axi_stream_interconnect_s2m_with_keep(
    num:8,
    nsize:"NUM <= 2? 1 :",
    addr:"addr",
    s00:"s00",
    m00:"m00")
    hash = TdlHash.new
    
    unless num.is_a? Hash
        hash.case_record(:num,num)
    else
        # hash.new_index(:num)= lambda { a = Parameter.new(num);a.name = "num";return a }
        # hash[:num] = lambda { a = Parameter.new(num);a.name = "num";return a }
        raise TdlError.new('axi_stream_interconnect_s2m_with_keep Parameter num TdlHash cant include Proc') if num.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(num)
            unless num[:name]
                a.name = "num"
            end
            return a }
        hash.[]=(:num,lam,false)
    end
            

    unless nsize.is_a? Hash
        hash.case_record(:nsize,nsize)
    else
        # hash.new_index(:nsize)= lambda { a = Parameter.new(nsize);a.name = "nsize";return a }
        # hash[:nsize] = lambda { a = Parameter.new(nsize);a.name = "nsize";return a }
        raise TdlError.new('axi_stream_interconnect_s2m_with_keep Parameter nsize TdlHash cant include Proc') if nsize.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(nsize)
            unless nsize[:name]
                a.name = "nsize"
            end
            return a }
        hash.[]=(:nsize,lam,false)
    end
            

    unless addr.is_a? Hash
        hash.case_record(:addr,addr)
    else
        # hash.new_index(:addr)= lambda { a = Logic.new(addr);a.name = "addr";return a }
        # hash[:addr] = lambda { a = Logic.new(addr);a.name = "addr";return a }
        raise TdlError.new('axi_stream_interconnect_s2m_with_keep Logic addr TdlHash cant include Proc') if addr.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(addr)
            unless addr[:name]
                a.name = "addr"
            end
            return a }
        hash.[]=(:addr,lam,false)
    end
            

    unless s00.is_a? Hash
        hash.case_record(:s00,s00)
    else
        # hash.new_index(:s00)= lambda { a = AxiStream.new(s00);a.name = "s00";return a }
        # hash[:s00] = lambda { a = AxiStream.new(s00);a.name = "s00";return a }
        raise TdlError.new('axi_stream_interconnect_s2m_with_keep AxiStream s00 TdlHash cant include Proc') if s00.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(s00)
            unless s00[:name]
                a.name = "s00"
            end
            return a }
        hash.[]=(:s00,lam,false)
    end
            

    unless m00.is_a? Hash
        hash.case_record(:m00,m00)
    else
        # hash.new_index(:m00)= lambda { a = AxiStream.new(m00);a.name = "m00";return a }
        # hash[:m00] = lambda { a = AxiStream.new(m00);a.name = "m00";return a }
        raise TdlError.new('axi_stream_interconnect_s2m_with_keep AxiStream m00 TdlHash cant include Proc') if m00.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(m00)
            unless m00[:name]
                a.name = "m00"
            end
            return a }
        hash.[]=(:m00,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axi_stream_interconnect_s2m_with_keep)
    hash.open_error = true
    return hash
end
inst_axi_stream_long_fifo( depth:2, byte_depth:8192*2, axis_in:"axis_in", axis_out:"axis_out") click to toggle source
# File lib/tdl/axi_stream/bak/axi_stream_long_fifo_auto.rb, line 102
def Tdl.inst_axi_stream_long_fifo(
    depth:2,
    byte_depth:8192*2,
    axis_in:"axis_in",
    axis_out:"axis_out")
    hash = TdlHash.new
    
    unless depth.is_a? Hash
        hash.case_record(:depth,depth)
    else
        # hash.new_index(:depth)= lambda { a = Parameter.new(depth);a.name = "depth";return a }
        # hash[:depth] = lambda { a = Parameter.new(depth);a.name = "depth";return a }
        raise TdlError.new('axi_stream_long_fifo Parameter depth TdlHash cant include Proc') if depth.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(depth)
            unless depth[:name]
                a.name = "depth"
            end
            return a }
        hash.[]=(:depth,lam,false)
    end
            

    unless byte_depth.is_a? Hash
        hash.case_record(:byte_depth,byte_depth)
    else
        # hash.new_index(:byte_depth)= lambda { a = Parameter.new(byte_depth);a.name = "byte_depth";return a }
        # hash[:byte_depth] = lambda { a = Parameter.new(byte_depth);a.name = "byte_depth";return a }
        raise TdlError.new('axi_stream_long_fifo Parameter byte_depth TdlHash cant include Proc') if byte_depth.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(byte_depth)
            unless byte_depth[:name]
                a.name = "byte_depth"
            end
            return a }
        hash.[]=(:byte_depth,lam,false)
    end
            

    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('axi_stream_long_fifo AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    unless axis_out.is_a? Hash
        hash.case_record(:axis_out,axis_out)
    else
        # hash.new_index(:axis_out)= lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        # hash[:axis_out] = lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        raise TdlError.new('axi_stream_long_fifo AxiStream axis_out TdlHash cant include Proc') if axis_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_out)
            unless axis_out[:name]
                a.name = "axis_out"
            end
            return a }
        hash.[]=(:axis_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axi_stream_long_fifo)
    hash.open_error = true
    return hash
end
inst_axi_stream_packet_fifo( depth:2 , axis_in:"axis_in", axis_out:"axis_out") click to toggle source
# File lib/tdl/axi_stream/bak/axi_stream_packet_fifo_auto.rb, line 100
def Tdl.inst_axi_stream_packet_fifo(
    depth:2   ,
    axis_in:"axis_in",
    axis_out:"axis_out")
    hash = TdlHash.new
    
    unless depth.is_a? Hash
        hash.case_record(:depth,depth)
    else
        # hash.new_index(:depth)= lambda { a = Parameter.new(depth);a.name = "depth";return a }
        # hash[:depth] = lambda { a = Parameter.new(depth);a.name = "depth";return a }
        raise TdlError.new('axi_stream_packet_fifo Parameter depth TdlHash cant include Proc') if depth.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(depth)
            unless depth[:name]
                a.name = "depth"
            end
            return a }
        hash.[]=(:depth,lam,false)
    end
            

    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('axi_stream_packet_fifo AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    unless axis_out.is_a? Hash
        hash.case_record(:axis_out,axis_out)
    else
        # hash.new_index(:axis_out)= lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        # hash[:axis_out] = lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        raise TdlError.new('axi_stream_packet_fifo AxiStream axis_out TdlHash cant include Proc') if axis_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_out)
            unless axis_out[:name]
                a.name = "axis_out"
            end
            return a }
        hash.[]=(:axis_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axi_stream_packet_fifo)
    hash.open_error = true
    return hash
end
inst_axi_stream_packet_fifo_with_info( depth:2, esize:8, info_in:"info_in", info_out:"info_out", axis_in:"axis_in", axis_out:"axis_out") click to toggle source
# File lib/tdl/axi_stream/bak/axi_stream_packet_fifo_with_info_auto.rb, line 106
def Tdl.inst_axi_stream_packet_fifo_with_info(
    depth:2,
    esize:8,
    info_in:"info_in",
    info_out:"info_out",
    axis_in:"axis_in",
    axis_out:"axis_out")
    hash = TdlHash.new
    
    unless depth.is_a? Hash
        hash.case_record(:depth,depth)
    else
        # hash.new_index(:depth)= lambda { a = Parameter.new(depth);a.name = "depth";return a }
        # hash[:depth] = lambda { a = Parameter.new(depth);a.name = "depth";return a }
        raise TdlError.new('axi_stream_packet_fifo_with_info Parameter depth TdlHash cant include Proc') if depth.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(depth)
            unless depth[:name]
                a.name = "depth"
            end
            return a }
        hash.[]=(:depth,lam,false)
    end
            

    unless esize.is_a? Hash
        hash.case_record(:esize,esize)
    else
        # hash.new_index(:esize)= lambda { a = Parameter.new(esize);a.name = "esize";return a }
        # hash[:esize] = lambda { a = Parameter.new(esize);a.name = "esize";return a }
        raise TdlError.new('axi_stream_packet_fifo_with_info Parameter esize TdlHash cant include Proc') if esize.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(esize)
            unless esize[:name]
                a.name = "esize"
            end
            return a }
        hash.[]=(:esize,lam,false)
    end
            

    unless info_in.is_a? Hash
        hash.case_record(:info_in,info_in)
    else
        # hash.new_index(:info_in)= lambda { a = Logic.new(info_in);a.name = "info_in";return a }
        # hash[:info_in] = lambda { a = Logic.new(info_in);a.name = "info_in";return a }
        raise TdlError.new('axi_stream_packet_fifo_with_info Logic info_in TdlHash cant include Proc') if info_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(info_in)
            unless info_in[:name]
                a.name = "info_in"
            end
            return a }
        hash.[]=(:info_in,lam,false)
    end
            

    unless info_out.is_a? Hash
        hash.case_record(:info_out,info_out)
    else
        # hash.new_index(:info_out)= lambda { a = Logic.new(info_out);a.name = "info_out";return a }
        # hash[:info_out] = lambda { a = Logic.new(info_out);a.name = "info_out";return a }
        raise TdlError.new('axi_stream_packet_fifo_with_info Logic info_out TdlHash cant include Proc') if info_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(info_out)
            unless info_out[:name]
                a.name = "info_out"
            end
            return a }
        hash.[]=(:info_out,lam,false)
    end
            

    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('axi_stream_packet_fifo_with_info AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    unless axis_out.is_a? Hash
        hash.case_record(:axis_out,axis_out)
    else
        # hash.new_index(:axis_out)= lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        # hash[:axis_out] = lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        raise TdlError.new('axi_stream_packet_fifo_with_info AxiStream axis_out TdlHash cant include Proc') if axis_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_out)
            unless axis_out[:name]
                a.name = "axis_out"
            end
            return a }
        hash.[]=(:axis_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axi_stream_packet_fifo_with_info)
    hash.open_error = true
    return hash
end
inst_axi_stream_partition( valve:"valve", partition_len:"partition_len", req_new_len:"req_new_len", axis_in:"axis_in", axis_out:"axis_out") click to toggle source
# File lib/tdl/axi_stream/bak/axi_stream_partition_auto.rb, line 103
def Tdl.inst_axi_stream_partition(
    valve:"valve",
    partition_len:"partition_len",
    req_new_len:"req_new_len",
    axis_in:"axis_in",
    axis_out:"axis_out")
    hash = TdlHash.new
    
    unless valve.is_a? Hash
        hash.case_record(:valve,valve)
    else
        # hash.new_index(:valve)= lambda { a = Logic.new(valve);a.name = "valve";return a }
        # hash[:valve] = lambda { a = Logic.new(valve);a.name = "valve";return a }
        raise TdlError.new('axi_stream_partition Logic valve TdlHash cant include Proc') if valve.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(valve)
            unless valve[:name]
                a.name = "valve"
            end
            return a }
        hash.[]=(:valve,lam,false)
    end
            

    unless partition_len.is_a? Hash
        hash.case_record(:partition_len,partition_len)
    else
        # hash.new_index(:partition_len)= lambda { a = Logic.new(partition_len);a.name = "partition_len";return a }
        # hash[:partition_len] = lambda { a = Logic.new(partition_len);a.name = "partition_len";return a }
        raise TdlError.new('axi_stream_partition Logic partition_len TdlHash cant include Proc') if partition_len.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(partition_len)
            unless partition_len[:name]
                a.name = "partition_len"
            end
            return a }
        hash.[]=(:partition_len,lam,false)
    end
            

    unless req_new_len.is_a? Hash
        hash.case_record(:req_new_len,req_new_len)
    else
        # hash.new_index(:req_new_len)= lambda { a = Logic.new(req_new_len);a.name = "req_new_len";return a }
        # hash[:req_new_len] = lambda { a = Logic.new(req_new_len);a.name = "req_new_len";return a }
        raise TdlError.new('axi_stream_partition Logic req_new_len TdlHash cant include Proc') if req_new_len.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(req_new_len)
            unless req_new_len[:name]
                a.name = "req_new_len"
            end
            return a }
        hash.[]=(:req_new_len,lam,false)
    end
            

    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('axi_stream_partition AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    unless axis_out.is_a? Hash
        hash.case_record(:axis_out,axis_out)
    else
        # hash.new_index(:axis_out)= lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        # hash[:axis_out] = lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        raise TdlError.new('axi_stream_partition AxiStream axis_out TdlHash cant include Proc') if axis_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_out)
            unless axis_out[:name]
                a.name = "axis_out"
            end
            return a }
        hash.[]=(:axis_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axi_stream_partition)
    hash.open_error = true
    return hash
end
inst_axi_stream_partition_a1( valve:"valve", partition_len:"partition_len", axis_in:"axis_in", axis_out:"axis_out") click to toggle source
# File lib/tdl/axi_stream/bak/axi_stream_partition_A1_auto.rb, line 101
def Tdl.inst_axi_stream_partition_a1(
    valve:"valve",
    partition_len:"partition_len",
    axis_in:"axis_in",
    axis_out:"axis_out")
    hash = TdlHash.new
    
    unless valve.is_a? Hash
        hash.case_record(:valve,valve)
    else
        # hash.new_index(:valve)= lambda { a = Logic.new(valve);a.name = "valve";return a }
        # hash[:valve] = lambda { a = Logic.new(valve);a.name = "valve";return a }
        raise TdlError.new('axi_stream_partition_a1 Logic valve TdlHash cant include Proc') if valve.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(valve)
            unless valve[:name]
                a.name = "valve"
            end
            return a }
        hash.[]=(:valve,lam,false)
    end
            

    unless partition_len.is_a? Hash
        hash.case_record(:partition_len,partition_len)
    else
        # hash.new_index(:partition_len)= lambda { a = Logic.new(partition_len);a.name = "partition_len";return a }
        # hash[:partition_len] = lambda { a = Logic.new(partition_len);a.name = "partition_len";return a }
        raise TdlError.new('axi_stream_partition_a1 Logic partition_len TdlHash cant include Proc') if partition_len.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(partition_len)
            unless partition_len[:name]
                a.name = "partition_len"
            end
            return a }
        hash.[]=(:partition_len,lam,false)
    end
            

    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('axi_stream_partition_a1 AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    unless axis_out.is_a? Hash
        hash.case_record(:axis_out,axis_out)
    else
        # hash.new_index(:axis_out)= lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        # hash[:axis_out] = lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        raise TdlError.new('axi_stream_partition_a1 AxiStream axis_out TdlHash cant include Proc') if axis_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_out)
            unless axis_out[:name]
                a.name = "axis_out"
            end
            return a }
        hash.[]=(:axis_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axi_stream_partition_a1)
    hash.open_error = true
    return hash
end
inst_axi_streams_combin( mode:"BOTH", cut_or_combin_body:"ON", dsize:8, new_body_len:"new_body_len", trigger_signal:"trigger_signal", head_inf:"head_inf", body_inf:"body_inf", end_inf:"end_inf", m00:"m00") click to toggle source
# File lib/tdl/axi_stream/bak/axi_streams_combin_auto.rb, line 114
def Tdl.inst_axi_streams_combin(
    mode:"BOTH",
    cut_or_combin_body:"ON",
    dsize:8,
    new_body_len:"new_body_len",
    trigger_signal:"trigger_signal",
    head_inf:"head_inf",
    body_inf:"body_inf",
    end_inf:"end_inf",
    m00:"m00")
    hash = TdlHash.new
    
    unless mode.is_a? Hash
        hash.case_record(:mode,mode)
    else
        # hash.new_index(:mode)= lambda { a = Parameter.new(mode);a.name = "mode";return a }
        # hash[:mode] = lambda { a = Parameter.new(mode);a.name = "mode";return a }
        raise TdlError.new('axi_streams_combin Parameter mode TdlHash cant include Proc') if mode.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(mode)
            unless mode[:name]
                a.name = "mode"
            end
            return a }
        hash.[]=(:mode,lam,false)
    end
            

    unless cut_or_combin_body.is_a? Hash
        hash.case_record(:cut_or_combin_body,cut_or_combin_body)
    else
        # hash.new_index(:cut_or_combin_body)= lambda { a = Parameter.new(cut_or_combin_body);a.name = "cut_or_combin_body";return a }
        # hash[:cut_or_combin_body] = lambda { a = Parameter.new(cut_or_combin_body);a.name = "cut_or_combin_body";return a }
        raise TdlError.new('axi_streams_combin Parameter cut_or_combin_body TdlHash cant include Proc') if cut_or_combin_body.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(cut_or_combin_body)
            unless cut_or_combin_body[:name]
                a.name = "cut_or_combin_body"
            end
            return a }
        hash.[]=(:cut_or_combin_body,lam,false)
    end
            

    unless dsize.is_a? Hash
        hash.case_record(:dsize,dsize)
    else
        # hash.new_index(:dsize)= lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        # hash[:dsize] = lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        raise TdlError.new('axi_streams_combin Parameter dsize TdlHash cant include Proc') if dsize.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(dsize)
            unless dsize[:name]
                a.name = "dsize"
            end
            return a }
        hash.[]=(:dsize,lam,false)
    end
            

    unless new_body_len.is_a? Hash
        hash.case_record(:new_body_len,new_body_len)
    else
        # hash.new_index(:new_body_len)= lambda { a = Logic.new(new_body_len);a.name = "new_body_len";return a }
        # hash[:new_body_len] = lambda { a = Logic.new(new_body_len);a.name = "new_body_len";return a }
        raise TdlError.new('axi_streams_combin Logic new_body_len TdlHash cant include Proc') if new_body_len.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(new_body_len)
            unless new_body_len[:name]
                a.name = "new_body_len"
            end
            return a }
        hash.[]=(:new_body_len,lam,false)
    end
            

    unless trigger_signal.is_a? Hash
        hash.case_record(:trigger_signal,trigger_signal)
    else
        # hash.new_index(:trigger_signal)= lambda { a = Logic.new(trigger_signal);a.name = "trigger_signal";return a }
        # hash[:trigger_signal] = lambda { a = Logic.new(trigger_signal);a.name = "trigger_signal";return a }
        raise TdlError.new('axi_streams_combin Logic trigger_signal TdlHash cant include Proc') if trigger_signal.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(trigger_signal)
            unless trigger_signal[:name]
                a.name = "trigger_signal"
            end
            return a }
        hash.[]=(:trigger_signal,lam,false)
    end
            

    unless head_inf.is_a? Hash
        hash.case_record(:head_inf,head_inf)
    else
        # hash.new_index(:head_inf)= lambda { a = AxiStream.new(head_inf);a.name = "head_inf";return a }
        # hash[:head_inf] = lambda { a = AxiStream.new(head_inf);a.name = "head_inf";return a }
        raise TdlError.new('axi_streams_combin AxiStream head_inf TdlHash cant include Proc') if head_inf.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(head_inf)
            unless head_inf[:name]
                a.name = "head_inf"
            end
            return a }
        hash.[]=(:head_inf,lam,false)
    end
            

    unless body_inf.is_a? Hash
        hash.case_record(:body_inf,body_inf)
    else
        # hash.new_index(:body_inf)= lambda { a = AxiStream.new(body_inf);a.name = "body_inf";return a }
        # hash[:body_inf] = lambda { a = AxiStream.new(body_inf);a.name = "body_inf";return a }
        raise TdlError.new('axi_streams_combin AxiStream body_inf TdlHash cant include Proc') if body_inf.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(body_inf)
            unless body_inf[:name]
                a.name = "body_inf"
            end
            return a }
        hash.[]=(:body_inf,lam,false)
    end
            

    unless end_inf.is_a? Hash
        hash.case_record(:end_inf,end_inf)
    else
        # hash.new_index(:end_inf)= lambda { a = AxiStream.new(end_inf);a.name = "end_inf";return a }
        # hash[:end_inf] = lambda { a = AxiStream.new(end_inf);a.name = "end_inf";return a }
        raise TdlError.new('axi_streams_combin AxiStream end_inf TdlHash cant include Proc') if end_inf.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(end_inf)
            unless end_inf[:name]
                a.name = "end_inf"
            end
            return a }
        hash.[]=(:end_inf,lam,false)
    end
            

    unless m00.is_a? Hash
        hash.case_record(:m00,m00)
    else
        # hash.new_index(:m00)= lambda { a = AxiStream.new(m00);a.name = "m00";return a }
        # hash[:m00] = lambda { a = AxiStream.new(m00);a.name = "m00";return a }
        raise TdlError.new('axi_streams_combin AxiStream m00 TdlHash cant include Proc') if m00.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(m00)
            unless m00[:name]
                a.name = "m00"
            end
            return a }
        hash.[]=(:m00,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axi_streams_combin)
    hash.open_error = true
    return hash
end
inst_axi_streams_scaler(mode:"BOTH", cut_or_combin_body:"ON", dsize:8, new_body_len:"new_body_len", head_inf:"head_inf", body_inf:"body_inf", end_inf:"end_inf", m00:"m00") click to toggle source
# File lib/tdl/axi_stream/bak/axi_streams_scaler.rb, line 104
def Tdl.inst_axi_streams_scaler(mode:"BOTH",
    cut_or_combin_body:"ON",
    dsize:8,
    new_body_len:"new_body_len",
    head_inf:"head_inf",
    body_inf:"body_inf",
    end_inf:"end_inf",
    m00:"m00")
    hash = TdlHash.new

    unless mode.is_a? Hash
        # hash.new_index(:mode) = mode
        if mode.is_a? BaseElm
            hash.[]=(:mode,mode,true)
        else
            hash.[]=(:mode,mode,false)
        end
    else
        # hash.new_index(:mode)= lambda { a = Parameter.new(mode);a.name = "mode";return a }
        # hash[:mode] = lambda { a = Parameter.new(mode);a.name = "mode";return a }
        lam = lambda {
            a = Parameter.new(mode)
            unless mode[:name]
                a.name = "mode"
            end
            return a }
        hash.[]=(:mode,lam,false)
    end


    unless cut_or_combin_body.is_a? Hash
        # hash.new_index(:cut_or_combin_body) = cut_or_combin_body
        if cut_or_combin_body.is_a? BaseElm
            hash.[]=(:cut_or_combin_body,cut_or_combin_body,true)
        else
            hash.[]=(:cut_or_combin_body,cut_or_combin_body,false)
        end
    else
        # hash.new_index(:cut_or_combin_body)= lambda { a = Parameter.new(cut_or_combin_body);a.name = "cut_or_combin_body";return a }
        # hash[:cut_or_combin_body] = lambda { a = Parameter.new(cut_or_combin_body);a.name = "cut_or_combin_body";return a }
        lam = lambda {
            a = Parameter.new(cut_or_combin_body)
            unless cut_or_combin_body[:name]
                a.name = "cut_or_combin_body"
            end
            return a }
        hash.[]=(:cut_or_combin_body,lam,false)
    end


    unless dsize.is_a? Hash
        # hash.new_index(:dsize) = dsize
        if dsize.is_a? BaseElm
            hash.[]=(:dsize,dsize,true)
        else
            hash.[]=(:dsize,dsize,false)
        end
    else
        # hash.new_index(:dsize)= lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        # hash[:dsize] = lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        lam = lambda {
            a = Parameter.new(dsize)
            unless dsize[:name]
                a.name = "dsize"
            end
            return a }
        hash.[]=(:dsize,lam,false)
    end


    unless new_body_len.is_a? Hash
        # hash.new_index(:new_body_len) = new_body_len
        if new_body_len.is_a? BaseElm
            hash.[]=(:new_body_len,new_body_len,true)
        else
            hash.[]=(:new_body_len,new_body_len,false)
        end
    else
        # hash.new_index(:new_body_len)= lambda { a = Logic.new(new_body_len);a.name = "new_body_len";return a }
        # hash[:new_body_len] = lambda { a = Logic.new(new_body_len);a.name = "new_body_len";return a }
        lam = lambda {
            a = Logic.new(new_body_len)
            unless new_body_len[:name]
                a.name = "new_body_len"
            end
            return a }
        hash.[]=(:new_body_len,lam,false)
    end


    unless head_inf.is_a? Hash
        # hash.new_index(:head_inf) = head_inf
        if head_inf.is_a? BaseElm
            hash.[]=(:head_inf,head_inf,true)
        else
            hash.[]=(:head_inf,head_inf,false)
        end
    else
        # hash.new_index(:head_inf)= lambda { a = AxiStream.new(head_inf);a.name = "head_inf";return a }
        # hash[:head_inf] = lambda { a = AxiStream.new(head_inf);a.name = "head_inf";return a }
        lam = lambda {
            a = AxiStream.new(head_inf)
            unless head_inf[:name]
                a.name = "head_inf"
            end
            return a }
        hash.[]=(:head_inf,lam,false)
    end


    unless body_inf.is_a? Hash
        # hash.new_index(:body_inf) = body_inf
        if body_inf.is_a? BaseElm
            hash.[]=(:body_inf,body_inf,true)
        else
            hash.[]=(:body_inf,body_inf,false)
        end
    else
        # hash.new_index(:body_inf)= lambda { a = AxiStream.new(body_inf);a.name = "body_inf";return a }
        # hash[:body_inf] = lambda { a = AxiStream.new(body_inf);a.name = "body_inf";return a }
        lam = lambda {
            a = AxiStream.new(body_inf)
            unless body_inf[:name]
                a.name = "body_inf"
            end
            return a }
        hash.[]=(:body_inf,lam,false)
    end


    unless end_inf.is_a? Hash
        # hash.new_index(:end_inf) = end_inf
        if end_inf.is_a? BaseElm
            hash.[]=(:end_inf,end_inf,true)
        else
            hash.[]=(:end_inf,end_inf,false)
        end
    else
        # hash.new_index(:end_inf)= lambda { a = AxiStream.new(end_inf);a.name = "end_inf";return a }
        # hash[:end_inf] = lambda { a = AxiStream.new(end_inf);a.name = "end_inf";return a }
        lam = lambda {
            a = AxiStream.new(end_inf)
            unless end_inf[:name]
                a.name = "end_inf"
            end
            return a }
        hash.[]=(:end_inf,lam,false)
    end


    unless m00.is_a? Hash
        # hash.new_index(:m00) = m00
        if m00.is_a? BaseElm
            hash.[]=(:m00,m00,true)
        else
            hash.[]=(:m00,m00,false)
        end
    else
        # hash.new_index(:m00)= lambda { a = AxiStream.new(m00);a.name = "m00";return a }
        # hash[:m00] = lambda { a = AxiStream.new(m00);a.name = "m00";return a }
        lam = lambda {
            a = AxiStream.new(m00)
            unless m00[:name]
                a.name = "m00"
            end
            return a }
        hash.[]=(:m00,lam,false)
    end


    Tdl.module_stack  << lambda {
        hash.each do |k,v|
            if v.is_a? Proc
                hash.[]=(k,v.call,false)
            elsif v.is_a? Array
                unless v.empty?
                    if v[0].is_a? Axi4
                        cm = v[0].copy(name:k,idsize:Math.log2(v.length).ceil+v[0].idsize)
                    else
                        cm = v[0].copy(name:k)
                    end
                    cm.<<(*v)
                    # hash[k] = cm
                    hash.[]=(k,cm)
                else
                    hash.[]=(k,nil,false)
                end
            else
                # hash[k] = v
            end
        end
        hash.check_use("axi_streams_scaler")
        AxiStream.axi_streams_scaler(hash)
    }
    return hash
end
inst_axis_append( mode:"BOTH", dsize:8, head_field_len:16*8, head_field_name:"HEAD Filed", end_field_len:16*8, end_field_name:"END Filed", head_value:"head_value", end_value:"end_value", origin_in:"origin_in", append_out:"append_out") click to toggle source
# File lib/tdl/axi_stream/bak/axis_append_auto.rb, line 114
def Tdl.inst_axis_append(
    mode:"BOTH",
    dsize:8,
    head_field_len:16*8,
    head_field_name:"HEAD Filed",
    end_field_len:16*8,
    end_field_name:"END Filed",
    head_value:"head_value",
    end_value:"end_value",
    origin_in:"origin_in",
    append_out:"append_out")
    hash = TdlHash.new
    
    unless mode.is_a? Hash
        hash.case_record(:mode,mode)
    else
        # hash.new_index(:mode)= lambda { a = Parameter.new(mode);a.name = "mode";return a }
        # hash[:mode] = lambda { a = Parameter.new(mode);a.name = "mode";return a }
        raise TdlError.new('axis_append Parameter mode TdlHash cant include Proc') if mode.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(mode)
            unless mode[:name]
                a.name = "mode"
            end
            return a }
        hash.[]=(:mode,lam,false)
    end
            

    unless dsize.is_a? Hash
        hash.case_record(:dsize,dsize)
    else
        # hash.new_index(:dsize)= lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        # hash[:dsize] = lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        raise TdlError.new('axis_append Parameter dsize TdlHash cant include Proc') if dsize.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(dsize)
            unless dsize[:name]
                a.name = "dsize"
            end
            return a }
        hash.[]=(:dsize,lam,false)
    end
            

    unless head_field_len.is_a? Hash
        hash.case_record(:head_field_len,head_field_len)
    else
        # hash.new_index(:head_field_len)= lambda { a = Parameter.new(head_field_len);a.name = "head_field_len";return a }
        # hash[:head_field_len] = lambda { a = Parameter.new(head_field_len);a.name = "head_field_len";return a }
        raise TdlError.new('axis_append Parameter head_field_len TdlHash cant include Proc') if head_field_len.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(head_field_len)
            unless head_field_len[:name]
                a.name = "head_field_len"
            end
            return a }
        hash.[]=(:head_field_len,lam,false)
    end
            

    unless head_field_name.is_a? Hash
        hash.case_record(:head_field_name,head_field_name)
    else
        # hash.new_index(:head_field_name)= lambda { a = Parameter.new(head_field_name);a.name = "head_field_name";return a }
        # hash[:head_field_name] = lambda { a = Parameter.new(head_field_name);a.name = "head_field_name";return a }
        raise TdlError.new('axis_append Parameter head_field_name TdlHash cant include Proc') if head_field_name.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(head_field_name)
            unless head_field_name[:name]
                a.name = "head_field_name"
            end
            return a }
        hash.[]=(:head_field_name,lam,false)
    end
            

    unless end_field_len.is_a? Hash
        hash.case_record(:end_field_len,end_field_len)
    else
        # hash.new_index(:end_field_len)= lambda { a = Parameter.new(end_field_len);a.name = "end_field_len";return a }
        # hash[:end_field_len] = lambda { a = Parameter.new(end_field_len);a.name = "end_field_len";return a }
        raise TdlError.new('axis_append Parameter end_field_len TdlHash cant include Proc') if end_field_len.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(end_field_len)
            unless end_field_len[:name]
                a.name = "end_field_len"
            end
            return a }
        hash.[]=(:end_field_len,lam,false)
    end
            

    unless end_field_name.is_a? Hash
        hash.case_record(:end_field_name,end_field_name)
    else
        # hash.new_index(:end_field_name)= lambda { a = Parameter.new(end_field_name);a.name = "end_field_name";return a }
        # hash[:end_field_name] = lambda { a = Parameter.new(end_field_name);a.name = "end_field_name";return a }
        raise TdlError.new('axis_append Parameter end_field_name TdlHash cant include Proc') if end_field_name.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(end_field_name)
            unless end_field_name[:name]
                a.name = "end_field_name"
            end
            return a }
        hash.[]=(:end_field_name,lam,false)
    end
            

    unless head_value.is_a? Hash
        hash.case_record(:head_value,head_value)
    else
        # hash.new_index(:head_value)= lambda { a = Logic.new(head_value);a.name = "head_value";return a }
        # hash[:head_value] = lambda { a = Logic.new(head_value);a.name = "head_value";return a }
        raise TdlError.new('axis_append Logic head_value TdlHash cant include Proc') if head_value.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(head_value)
            unless head_value[:name]
                a.name = "head_value"
            end
            return a }
        hash.[]=(:head_value,lam,false)
    end
            

    unless end_value.is_a? Hash
        hash.case_record(:end_value,end_value)
    else
        # hash.new_index(:end_value)= lambda { a = Logic.new(end_value);a.name = "end_value";return a }
        # hash[:end_value] = lambda { a = Logic.new(end_value);a.name = "end_value";return a }
        raise TdlError.new('axis_append Logic end_value TdlHash cant include Proc') if end_value.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(end_value)
            unless end_value[:name]
                a.name = "end_value"
            end
            return a }
        hash.[]=(:end_value,lam,false)
    end
            

    unless origin_in.is_a? Hash
        hash.case_record(:origin_in,origin_in)
    else
        # hash.new_index(:origin_in)= lambda { a = AxiStream.new(origin_in);a.name = "origin_in";return a }
        # hash[:origin_in] = lambda { a = AxiStream.new(origin_in);a.name = "origin_in";return a }
        raise TdlError.new('axis_append AxiStream origin_in TdlHash cant include Proc') if origin_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(origin_in)
            unless origin_in[:name]
                a.name = "origin_in"
            end
            return a }
        hash.[]=(:origin_in,lam,false)
    end
            

    unless append_out.is_a? Hash
        hash.case_record(:append_out,append_out)
    else
        # hash.new_index(:append_out)= lambda { a = AxiStream.new(append_out);a.name = "append_out";return a }
        # hash[:append_out] = lambda { a = AxiStream.new(append_out);a.name = "append_out";return a }
        raise TdlError.new('axis_append AxiStream append_out TdlHash cant include Proc') if append_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(append_out)
            unless append_out[:name]
                a.name = "append_out"
            end
            return a }
        hash.[]=(:append_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axis_append)
    hash.open_error = true
    return hash
end
inst_axis_append_a1(mode:"BOTH",dsize:8,head_field_len:16*8,head_field_name:"HEAD Filed",end_field_len:16*8,end_field_name:"END Filed",enable:"enable",head_value:"head_value",end_value:"end_value",origin_in:"origin_in",append_out:"append_out") click to toggle source
# File lib/tdl/axi_stream/bak/axis_append_A1.rb, line 82
def self.inst_axis_append_a1(mode:"BOTH",dsize:8,head_field_len:16*8,head_field_name:"HEAD Filed",end_field_len:16*8,end_field_name:"END Filed",enable:"enable",head_value:"head_value",end_value:"end_value",origin_in:"origin_in",append_out:"append_out")
    hash = TdlHash.new

    unless mode.is_a? Hash
        # hash.new_index(:mode) = mode
        if mode.is_a? InfElm
            hash.[]=(:mode,mode,true)
        else
            hash.[]=(:mode,mode,false)
        end
    else
        # hash.new_index(:mode)= lambda { a = Parameter.new(mode);a.name = "mode";return a }
        # hash[:mode] = lambda { a = Parameter.new(mode);a.name = "mode";return a }
        hash.[]=(:mode,lambda { a = Parameter.new(mode);a.name = "mode";return a },false)
    end


    unless dsize.is_a? Hash
        # hash.new_index(:dsize) = dsize
        if dsize.is_a? InfElm
            hash.[]=(:dsize,dsize,true)
        else
            hash.[]=(:dsize,dsize,false)
        end
    else
        # hash.new_index(:dsize)= lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        # hash[:dsize] = lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        hash.[]=(:dsize,lambda { a = Parameter.new(dsize);a.name = "dsize";return a },false)
    end


    unless head_field_len.is_a? Hash
        # hash.new_index(:head_field_len) = head_field_len
        if head_field_len.is_a? InfElm
            hash.[]=(:head_field_len,head_field_len,true)
        else
            hash.[]=(:head_field_len,head_field_len,false)
        end
    else
        # hash.new_index(:head_field_len)= lambda { a = Parameter.new(head_field_len);a.name = "head_field_len";return a }
        # hash[:head_field_len] = lambda { a = Parameter.new(head_field_len);a.name = "head_field_len";return a }
        hash.[]=(:head_field_len,lambda { a = Parameter.new(head_field_len);a.name = "head_field_len";return a },false)
    end


    unless head_field_name.is_a? Hash
        # hash.new_index(:head_field_name) = head_field_name
        if head_field_name.is_a? InfElm
            hash.[]=(:head_field_name,head_field_name,true)
        else
            hash.[]=(:head_field_name,head_field_name,false)
        end
    else
        # hash.new_index(:head_field_name)= lambda { a = Parameter.new(head_field_name);a.name = "head_field_name";return a }
        # hash[:head_field_name] = lambda { a = Parameter.new(head_field_name);a.name = "head_field_name";return a }
        hash.[]=(:head_field_name,lambda { a = Parameter.new(head_field_name);a.name = "head_field_name";return a },false)
    end


    unless end_field_len.is_a? Hash
        # hash.new_index(:end_field_len) = end_field_len
        if end_field_len.is_a? InfElm
            hash.[]=(:end_field_len,end_field_len,true)
        else
            hash.[]=(:end_field_len,end_field_len,false)
        end
    else
        # hash.new_index(:end_field_len)= lambda { a = Parameter.new(end_field_len);a.name = "end_field_len";return a }
        # hash[:end_field_len] = lambda { a = Parameter.new(end_field_len);a.name = "end_field_len";return a }
        hash.[]=(:end_field_len,lambda { a = Parameter.new(end_field_len);a.name = "end_field_len";return a },false)
    end


    unless end_field_name.is_a? Hash
        # hash.new_index(:end_field_name) = end_field_name
        if end_field_name.is_a? InfElm
            hash.[]=(:end_field_name,end_field_name,true)
        else
            hash.[]=(:end_field_name,end_field_name,false)
        end
    else
        # hash.new_index(:end_field_name)= lambda { a = Parameter.new(end_field_name);a.name = "end_field_name";return a }
        # hash[:end_field_name] = lambda { a = Parameter.new(end_field_name);a.name = "end_field_name";return a }
        hash.[]=(:end_field_name,lambda { a = Parameter.new(end_field_name);a.name = "end_field_name";return a },false)
    end


    unless enable.is_a? Hash
        # hash.new_index(:enable) = enable
        if enable.is_a? InfElm
            hash.[]=(:enable,enable,true)
        else
            hash.[]=(:enable,enable,false)
        end
    else
        # hash.new_index(:enable)= lambda { a = Logic.new(enable);a.name = "enable";return a }
        # hash[:enable] = lambda { a = Logic.new(enable);a.name = "enable";return a }
        hash.[]=(:enable,lambda { a = Logic.new(enable);a.name = "enable";return a },false)
    end


    unless head_value.is_a? Hash
        # hash.new_index(:head_value) = head_value
        if head_value.is_a? InfElm
            hash.[]=(:head_value,head_value,true)
        else
            hash.[]=(:head_value,head_value,false)
        end
    else
        # hash.new_index(:head_value)= lambda { a = Logic.new(head_value);a.name = "head_value";return a }
        # hash[:head_value] = lambda { a = Logic.new(head_value);a.name = "head_value";return a }
        hash.[]=(:head_value,lambda { a = Logic.new(head_value);a.name = "head_value";return a },false)
    end


    unless end_value.is_a? Hash
        # hash.new_index(:end_value) = end_value
        if end_value.is_a? InfElm
            hash.[]=(:end_value,end_value,true)
        else
            hash.[]=(:end_value,end_value,false)
        end
    else
        # hash.new_index(:end_value)= lambda { a = Logic.new(end_value);a.name = "end_value";return a }
        # hash[:end_value] = lambda { a = Logic.new(end_value);a.name = "end_value";return a }
        hash.[]=(:end_value,lambda { a = Logic.new(end_value);a.name = "end_value";return a },false)
    end


    unless origin_in.is_a? Hash
        # hash.new_index(:origin_in) = origin_in
        if origin_in.is_a? InfElm
            hash.[]=(:origin_in,origin_in,true)
        else
            hash.[]=(:origin_in,origin_in,false)
        end
    else
        # hash.new_index(:origin_in)= lambda { a = AxiStream.new(origin_in);a.name = "origin_in";return a }
        # hash[:origin_in] = lambda { a = AxiStream.new(origin_in);a.name = "origin_in";return a }
        hash.[]=(:origin_in,lambda { a = AxiStream.new(origin_in);a.name = "origin_in";return a },false)
    end


    unless append_out.is_a? Hash
        # hash.new_index(:append_out) = append_out
        if append_out.is_a? InfElm
            hash.[]=(:append_out,append_out,true)
        else
            hash.[]=(:append_out,append_out,false)
        end
    else
        # hash.new_index(:append_out)= lambda { a = AxiStream.new(append_out);a.name = "append_out";return a }
        # hash[:append_out] = lambda { a = AxiStream.new(append_out);a.name = "append_out";return a }
        hash.[]=(:append_out,lambda { a = AxiStream.new(append_out);a.name = "append_out";return a },false)
    end


    Tdl.module_stack  << lambda {
        hash.each do |k,v|
            if v.is_a? Proc
                hash.[]=(k,v.call,false)
            elsif v.is_a? Array
                unless v.empty?
                    if v[0].is_a? Axi4
                        cm = v[0].copy(name:k,idsize:Math.log2(v.length).ceil+v[0].idsize)
                    else
                        cm = v[0].copy(name:k)
                    end
                    cm.<<(*v)
                    # hash[k] = cm
                    hash.[]=(k,cm)
                else
                    hash.[]=(k,nil,false)
                end
            else
                # hash[k] = v
            end
        end
        hash.check_use("axis_append_a1")
        AxiStream.axis_append_a1(hash)
    }
    return hash
end
inst_axis_combin_with_fifo( mode:"BOTH", cut_or_combin_body:"ON", new_body_len:"new_body_len", head_inf:"head_inf", body_inf:"body_inf", end_inf:"end_inf", m00:"m00") click to toggle source
# File lib/tdl/axi_stream/bak/axis_combin_with_fifo_auto.rb, line 110
def Tdl.inst_axis_combin_with_fifo(
    mode:"BOTH",
    cut_or_combin_body:"ON",
    new_body_len:"new_body_len",
    head_inf:"head_inf",
    body_inf:"body_inf",
    end_inf:"end_inf",
    m00:"m00")
    hash = TdlHash.new
    
    unless mode.is_a? Hash
        hash.case_record(:mode,mode)
    else
        # hash.new_index(:mode)= lambda { a = Parameter.new(mode);a.name = "mode";return a }
        # hash[:mode] = lambda { a = Parameter.new(mode);a.name = "mode";return a }
        raise TdlError.new('axis_combin_with_fifo Parameter mode TdlHash cant include Proc') if mode.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(mode)
            unless mode[:name]
                a.name = "mode"
            end
            return a }
        hash.[]=(:mode,lam,false)
    end
            

    unless cut_or_combin_body.is_a? Hash
        hash.case_record(:cut_or_combin_body,cut_or_combin_body)
    else
        # hash.new_index(:cut_or_combin_body)= lambda { a = Parameter.new(cut_or_combin_body);a.name = "cut_or_combin_body";return a }
        # hash[:cut_or_combin_body] = lambda { a = Parameter.new(cut_or_combin_body);a.name = "cut_or_combin_body";return a }
        raise TdlError.new('axis_combin_with_fifo Parameter cut_or_combin_body TdlHash cant include Proc') if cut_or_combin_body.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(cut_or_combin_body)
            unless cut_or_combin_body[:name]
                a.name = "cut_or_combin_body"
            end
            return a }
        hash.[]=(:cut_or_combin_body,lam,false)
    end
            

    unless new_body_len.is_a? Hash
        hash.case_record(:new_body_len,new_body_len)
    else
        # hash.new_index(:new_body_len)= lambda { a = Logic.new(new_body_len);a.name = "new_body_len";return a }
        # hash[:new_body_len] = lambda { a = Logic.new(new_body_len);a.name = "new_body_len";return a }
        raise TdlError.new('axis_combin_with_fifo Logic new_body_len TdlHash cant include Proc') if new_body_len.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(new_body_len)
            unless new_body_len[:name]
                a.name = "new_body_len"
            end
            return a }
        hash.[]=(:new_body_len,lam,false)
    end
            

    unless head_inf.is_a? Hash
        hash.case_record(:head_inf,head_inf)
    else
        # hash.new_index(:head_inf)= lambda { a = AxiStream.new(head_inf);a.name = "head_inf";return a }
        # hash[:head_inf] = lambda { a = AxiStream.new(head_inf);a.name = "head_inf";return a }
        raise TdlError.new('axis_combin_with_fifo AxiStream head_inf TdlHash cant include Proc') if head_inf.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(head_inf)
            unless head_inf[:name]
                a.name = "head_inf"
            end
            return a }
        hash.[]=(:head_inf,lam,false)
    end
            

    unless body_inf.is_a? Hash
        hash.case_record(:body_inf,body_inf)
    else
        # hash.new_index(:body_inf)= lambda { a = AxiStream.new(body_inf);a.name = "body_inf";return a }
        # hash[:body_inf] = lambda { a = AxiStream.new(body_inf);a.name = "body_inf";return a }
        raise TdlError.new('axis_combin_with_fifo AxiStream body_inf TdlHash cant include Proc') if body_inf.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(body_inf)
            unless body_inf[:name]
                a.name = "body_inf"
            end
            return a }
        hash.[]=(:body_inf,lam,false)
    end
            

    unless end_inf.is_a? Hash
        hash.case_record(:end_inf,end_inf)
    else
        # hash.new_index(:end_inf)= lambda { a = AxiStream.new(end_inf);a.name = "end_inf";return a }
        # hash[:end_inf] = lambda { a = AxiStream.new(end_inf);a.name = "end_inf";return a }
        raise TdlError.new('axis_combin_with_fifo AxiStream end_inf TdlHash cant include Proc') if end_inf.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(end_inf)
            unless end_inf[:name]
                a.name = "end_inf"
            end
            return a }
        hash.[]=(:end_inf,lam,false)
    end
            

    unless m00.is_a? Hash
        hash.case_record(:m00,m00)
    else
        # hash.new_index(:m00)= lambda { a = AxiStream.new(m00);a.name = "m00";return a }
        # hash[:m00] = lambda { a = AxiStream.new(m00);a.name = "m00";return a }
        raise TdlError.new('axis_combin_with_fifo AxiStream m00 TdlHash cant include Proc') if m00.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(m00)
            unless m00[:name]
                a.name = "m00"
            end
            return a }
        hash.[]=(:m00,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axis_combin_with_fifo)
    hash.open_error = true
    return hash
end
inst_axis_connect_pipe( axis_in:"axis_in", axis_out:"axis_out") click to toggle source
# File lib/tdl/axi_stream/bak/axis_connect_pipe_auto.rb, line 97
def Tdl.inst_axis_connect_pipe(
    axis_in:"axis_in",
    axis_out:"axis_out")
    hash = TdlHash.new
    
    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('axis_connect_pipe AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    unless axis_out.is_a? Hash
        hash.case_record(:axis_out,axis_out)
    else
        # hash.new_index(:axis_out)= lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        # hash[:axis_out] = lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        raise TdlError.new('axis_connect_pipe AxiStream axis_out TdlHash cant include Proc') if axis_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_out)
            unless axis_out[:name]
                a.name = "axis_out"
            end
            return a }
        hash.[]=(:axis_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axis_connect_pipe)
    hash.open_error = true
    return hash
end
inst_axis_connect_pipe_a1( axis_in:"axis_in", axis_out:"axis_out") click to toggle source
# File lib/tdl/axi_stream/bak/axis_connect_pipe_A1.sv_auto.rb, line 97
def Tdl.inst_axis_connect_pipe_a1(
    axis_in:"axis_in",
    axis_out:"axis_out")
    hash = TdlHash.new
    
    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('axis_connect_pipe_a1 AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    unless axis_out.is_a? Hash
        hash.case_record(:axis_out,axis_out)
    else
        # hash.new_index(:axis_out)= lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        # hash[:axis_out] = lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        raise TdlError.new('axis_connect_pipe_a1 AxiStream axis_out TdlHash cant include Proc') if axis_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_out)
            unless axis_out[:name]
                a.name = "axis_out"
            end
            return a }
        hash.[]=(:axis_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axis_connect_pipe_a1)
    hash.open_error = true
    return hash
end
inst_axis_connect_pipe_with_info( ifsize:32, info_in:"info_in", info_out:"info_out", axis_in:"axis_in", axis_out:"axis_out") click to toggle source
# File lib/tdl/axi_stream/bak/axis_connect_pipe_with_info_auto.rb, line 104
def Tdl.inst_axis_connect_pipe_with_info(
    ifsize:32,
    info_in:"info_in",
    info_out:"info_out",
    axis_in:"axis_in",
    axis_out:"axis_out")
    hash = TdlHash.new
    
    unless ifsize.is_a? Hash
        hash.case_record(:ifsize,ifsize)
    else
        # hash.new_index(:ifsize)= lambda { a = Parameter.new(ifsize);a.name = "ifsize";return a }
        # hash[:ifsize] = lambda { a = Parameter.new(ifsize);a.name = "ifsize";return a }
        raise TdlError.new('axis_connect_pipe_with_info Parameter ifsize TdlHash cant include Proc') if ifsize.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(ifsize)
            unless ifsize[:name]
                a.name = "ifsize"
            end
            return a }
        hash.[]=(:ifsize,lam,false)
    end
            

    unless info_in.is_a? Hash
        hash.case_record(:info_in,info_in)
    else
        # hash.new_index(:info_in)= lambda { a = Logic.new(info_in);a.name = "info_in";return a }
        # hash[:info_in] = lambda { a = Logic.new(info_in);a.name = "info_in";return a }
        raise TdlError.new('axis_connect_pipe_with_info Logic info_in TdlHash cant include Proc') if info_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(info_in)
            unless info_in[:name]
                a.name = "info_in"
            end
            return a }
        hash.[]=(:info_in,lam,false)
    end
            

    unless info_out.is_a? Hash
        hash.case_record(:info_out,info_out)
    else
        # hash.new_index(:info_out)= lambda { a = Logic.new(info_out);a.name = "info_out";return a }
        # hash[:info_out] = lambda { a = Logic.new(info_out);a.name = "info_out";return a }
        raise TdlError.new('axis_connect_pipe_with_info Logic info_out TdlHash cant include Proc') if info_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(info_out)
            unless info_out[:name]
                a.name = "info_out"
            end
            return a }
        hash.[]=(:info_out,lam,false)
    end
            

    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('axis_connect_pipe_with_info AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    unless axis_out.is_a? Hash
        hash.case_record(:axis_out,axis_out)
    else
        # hash.new_index(:axis_out)= lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        # hash[:axis_out] = lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        raise TdlError.new('axis_connect_pipe_with_info AxiStream axis_out TdlHash cant include Proc') if axis_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_out)
            unless axis_out[:name]
                a.name = "axis_out"
            end
            return a }
        hash.[]=(:axis_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axis_connect_pipe_with_info)
    hash.open_error = true
    return hash
end
inst_axis_direct( slaver:"slaver", master:"master") click to toggle source
# File lib/tdl/axi_stream/bak/axis_direct_auto.rb, line 97
def Tdl.inst_axis_direct(
    slaver:"slaver",
    master:"master")
    hash = TdlHash.new
    
    unless slaver.is_a? Hash
        hash.case_record(:slaver,slaver)
    else
        # hash.new_index(:slaver)= lambda { a = AxiStream.new(slaver);a.name = "slaver";return a }
        # hash[:slaver] = lambda { a = AxiStream.new(slaver);a.name = "slaver";return a }
        raise TdlError.new('axis_direct AxiStream slaver TdlHash cant include Proc') if slaver.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(slaver)
            unless slaver[:name]
                a.name = "slaver"
            end
            return a }
        hash.[]=(:slaver,lam,false)
    end
            

    unless master.is_a? Hash
        hash.case_record(:master,master)
    else
        # hash.new_index(:master)= lambda { a = AxiStream.new(master);a.name = "master";return a }
        # hash[:master] = lambda { a = AxiStream.new(master);a.name = "master";return a }
        raise TdlError.new('axis_direct AxiStream master TdlHash cant include Proc') if master.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(master)
            unless master[:name]
                a.name = "master"
            end
            return a }
        hash.[]=(:master,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axis_direct)
    hash.open_error = true
    return hash
end
inst_axis_filter( button:"button", axis_in:"axis_in", axis_out:"axis_out") click to toggle source
# File lib/tdl/axi_stream/bak/axis_filter_auto.rb, line 99
def Tdl.inst_axis_filter(
    button:"button",
    axis_in:"axis_in",
    axis_out:"axis_out")
    hash = TdlHash.new
    
    unless button.is_a? Hash
        hash.case_record(:button,button)
    else
        # hash.new_index(:button)= lambda { a = Logic.new(button);a.name = "button";return a }
        # hash[:button] = lambda { a = Logic.new(button);a.name = "button";return a }
        raise TdlError.new('axis_filter Logic button TdlHash cant include Proc') if button.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(button)
            unless button[:name]
                a.name = "button"
            end
            return a }
        hash.[]=(:button,lam,false)
    end
            

    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('axis_filter AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    unless axis_out.is_a? Hash
        hash.case_record(:axis_out,axis_out)
    else
        # hash.new_index(:axis_out)= lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        # hash[:axis_out] = lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        raise TdlError.new('axis_filter AxiStream axis_out TdlHash cant include Proc') if axis_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_out)
            unless axis_out[:name]
                a.name = "axis_out"
            end
            return a }
        hash.[]=(:axis_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axis_filter)
    hash.open_error = true
    return hash
end
inst_axis_length_fill( length:"length", axis_in:"axis_in", axis_out:"axis_out") click to toggle source
# File lib/tdl/axi_stream/bak/axis_length_fill_auto.rb, line 99
def Tdl.inst_axis_length_fill(
    length:"length",
    axis_in:"axis_in",
    axis_out:"axis_out")
    hash = TdlHash.new
    
    unless length.is_a? Hash
        hash.case_record(:length,length)
    else
        # hash.new_index(:length)= lambda { a = Logic.new(length);a.name = "length";return a }
        # hash[:length] = lambda { a = Logic.new(length);a.name = "length";return a }
        raise TdlError.new('axis_length_fill Logic length TdlHash cant include Proc') if length.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(length)
            unless length[:name]
                a.name = "length"
            end
            return a }
        hash.[]=(:length,lam,false)
    end
            

    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('axis_length_fill AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    unless axis_out.is_a? Hash
        hash.case_record(:axis_out,axis_out)
    else
        # hash.new_index(:axis_out)= lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        # hash[:axis_out] = lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        raise TdlError.new('axis_length_fill AxiStream axis_out TdlHash cant include Proc') if axis_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_out)
            unless axis_out[:name]
                a.name = "axis_out"
            end
            return a }
        hash.[]=(:axis_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axis_length_fill)
    hash.open_error = true
    return hash
end
inst_axis_length_split( length:"length", axis_in:"axis_in", axis_out:"axis_out") click to toggle source
# File lib/tdl/axi_stream/bak/axis_length_split_auto.rb, line 99
def Tdl.inst_axis_length_split(
    length:"length",
    axis_in:"axis_in",
    axis_out:"axis_out")
    hash = TdlHash.new
    
    unless length.is_a? Hash
        hash.case_record(:length,length)
    else
        # hash.new_index(:length)= lambda { a = Logic.new(length);a.name = "length";return a }
        # hash[:length] = lambda { a = Logic.new(length);a.name = "length";return a }
        raise TdlError.new('axis_length_split Logic length TdlHash cant include Proc') if length.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(length)
            unless length[:name]
                a.name = "length"
            end
            return a }
        hash.[]=(:length,lam,false)
    end
            

    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('axis_length_split AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    unless axis_out.is_a? Hash
        hash.case_record(:axis_out,axis_out)
    else
        # hash.new_index(:axis_out)= lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        # hash[:axis_out] = lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        raise TdlError.new('axis_length_split AxiStream axis_out TdlHash cant include Proc') if axis_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_out)
            unless axis_out[:name]
                a.name = "axis_out"
            end
            return a }
        hash.[]=(:axis_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axis_length_split)
    hash.open_error = true
    return hash
end
inst_axis_length_split_with_addr( addr_step:1024 , origin_addr:"origin_addr", length:"length", band_addr:"band_addr", axis_in:"axis_in", axis_out:"axis_out") click to toggle source
# File lib/tdl/axi_stream/bak/axis_length_split_with_addr_auto.rb, line 106
def Tdl.inst_axis_length_split_with_addr(
    addr_step:1024      ,
    origin_addr:"origin_addr",
    length:"length",
    band_addr:"band_addr",
    axis_in:"axis_in",
    axis_out:"axis_out")
    hash = TdlHash.new
    
    unless addr_step.is_a? Hash
        hash.case_record(:addr_step,addr_step)
    else
        # hash.new_index(:addr_step)= lambda { a = Parameter.new(addr_step);a.name = "addr_step";return a }
        # hash[:addr_step] = lambda { a = Parameter.new(addr_step);a.name = "addr_step";return a }
        raise TdlError.new('axis_length_split_with_addr Parameter addr_step TdlHash cant include Proc') if addr_step.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(addr_step)
            unless addr_step[:name]
                a.name = "addr_step"
            end
            return a }
        hash.[]=(:addr_step,lam,false)
    end
            

    unless origin_addr.is_a? Hash
        hash.case_record(:origin_addr,origin_addr)
    else
        # hash.new_index(:origin_addr)= lambda { a = Logic.new(origin_addr);a.name = "origin_addr";return a }
        # hash[:origin_addr] = lambda { a = Logic.new(origin_addr);a.name = "origin_addr";return a }
        raise TdlError.new('axis_length_split_with_addr Logic origin_addr TdlHash cant include Proc') if origin_addr.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(origin_addr)
            unless origin_addr[:name]
                a.name = "origin_addr"
            end
            return a }
        hash.[]=(:origin_addr,lam,false)
    end
            

    unless length.is_a? Hash
        hash.case_record(:length,length)
    else
        # hash.new_index(:length)= lambda { a = Logic.new(length);a.name = "length";return a }
        # hash[:length] = lambda { a = Logic.new(length);a.name = "length";return a }
        raise TdlError.new('axis_length_split_with_addr Logic length TdlHash cant include Proc') if length.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(length)
            unless length[:name]
                a.name = "length"
            end
            return a }
        hash.[]=(:length,lam,false)
    end
            

    unless band_addr.is_a? Hash
        hash.case_record(:band_addr,band_addr)
    else
        # hash.new_index(:band_addr)= lambda { a = Logic.new(band_addr);a.name = "band_addr";return a }
        # hash[:band_addr] = lambda { a = Logic.new(band_addr);a.name = "band_addr";return a }
        raise TdlError.new('axis_length_split_with_addr Logic band_addr TdlHash cant include Proc') if band_addr.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(band_addr)
            unless band_addr[:name]
                a.name = "band_addr"
            end
            return a }
        hash.[]=(:band_addr,lam,false)
    end
            

    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('axis_length_split_with_addr AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    unless axis_out.is_a? Hash
        hash.case_record(:axis_out,axis_out)
    else
        # hash.new_index(:axis_out)= lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        # hash[:axis_out] = lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        raise TdlError.new('axis_length_split_with_addr AxiStream axis_out TdlHash cant include Proc') if axis_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_out)
            unless axis_out[:name]
                a.name = "axis_out"
            end
            return a }
        hash.[]=(:axis_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axis_length_split_with_addr)
    hash.open_error = true
    return hash
end
inst_axis_master_empty( master:"master") click to toggle source
# File lib/tdl/axi_stream/bak/axis_master_empty_auto.rb, line 71
def Tdl.inst_axis_master_empty(
    master:"master")
    hash = TdlHash.new
    
    unless master.is_a? Hash
        hash.case_record(:master,master)
    else
        # hash.new_index(:master)= lambda { a = AxiStream.new(master);a.name = "master";return a }
        # hash[:master] = lambda { a = AxiStream.new(master);a.name = "master";return a }
        raise TdlError.new('axis_master_empty AxiStream master TdlHash cant include Proc') if master.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(master)
            unless master[:name]
                a.name = "master"
            end
            return a }
        hash.[]=(:master,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axis_master_empty)
    hash.open_error = true
    return hash
end
inst_axis_mirrors( h:0, l:0, mode:"CDS_MODE", condition_data:"condition_data", axis_in:"axis_in", axis_mirror:"axis_mirror") click to toggle source
# File lib/tdl/axi_stream/bak/_axis_mirrors.rb, line 115
def Tdl.inst_axis_mirrors(
    h:0,
    l:0,
    mode:"CDS_MODE",
    condition_data:"condition_data",
    axis_in:"axis_in",
    axis_mirror:"axis_mirror")
    hash = TdlHash.new

    unless h.is_a? Hash
        # hash.new_index(:h) = h
        if h.is_a? BaseElm
            hash.[]=(:h,h,true)
        else
            hash.[]=(:h,h,false)
        end
    else
        # hash.new_index(:h)= lambda { a = Parameter.new(h);a.name = "h";return a }
        # hash[:h] = lambda { a = Parameter.new(h);a.name = "h";return a }
        lam = lambda {
            a = Parameter.new(h)
            unless h[:name]
                a.name = "h"
            end
            return a }
        hash.[]=(:h,lam,false)
    end


    unless l.is_a? Hash
        # hash.new_index(:l) = l
        if l.is_a? BaseElm
            hash.[]=(:l,l,true)
        else
            hash.[]=(:l,l,false)
        end
    else
        # hash.new_index(:l)= lambda { a = Parameter.new(l);a.name = "l";return a }
        # hash[:l] = lambda { a = Parameter.new(l);a.name = "l";return a }
        lam = lambda {
            a = Parameter.new(l)
            unless l[:name]
                a.name = "l"
            end
            return a }
        hash.[]=(:l,lam,false)
    end


    unless mode.is_a? Hash
        # hash.new_index(:mode) = mode
        if mode.is_a? BaseElm
            hash.[]=(:mode,mode,true)
        else
            hash.[]=(:mode,mode,false)
        end
    else
        # hash.new_index(:mode)= lambda { a = Parameter.new(mode);a.name = "mode";return a }
        # hash[:mode] = lambda { a = Parameter.new(mode);a.name = "mode";return a }
        lam = lambda {
            a = Parameter.new(mode)
            unless mode[:name]
                a.name = "mode"
            end
            return a }
        hash.[]=(:mode,lam,false)
    end


    unless condition_data.is_a? Hash
        # hash.new_index(:condition_data) = condition_data
        if condition_data.is_a? BaseElm
            hash.[]=(:condition_data,condition_data,true)
        else
            hash.[]=(:condition_data,condition_data,false)
        end
    else
        # hash.new_index(:condition_data)= lambda { a = Logic.new(condition_data);a.name = "condition_data";return a }
        # hash[:condition_data] = lambda { a = Logic.new(condition_data);a.name = "condition_data";return a }
        lam = lambda {
            a = Logic.new(condition_data)
            unless condition_data[:name]
                a.name = "condition_data"
            end
            return a }
        hash.[]=(:condition_data,lam,false)
    end


    unless axis_in.is_a? Hash
        # hash.new_index(:axis_in) = axis_in
        if axis_in.is_a? BaseElm
            hash.[]=(:axis_in,axis_in,true)
        else
            hash.[]=(:axis_in,axis_in,false)
        end
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end


    unless axis_mirror.is_a? Hash
        # hash.new_index(:axis_mirror) = axis_mirror
        if axis_mirror.is_a? BaseElm
            hash.[]=(:axis_mirror,axis_mirror,true)
        else
            hash.[]=(:axis_mirror,axis_mirror,false)
        end
    else
        # hash.new_index(:axis_mirror)= lambda { a = AxiStream.new(axis_mirror);a.name = "axis_mirror";return a }
        # hash[:axis_mirror] = lambda { a = AxiStream.new(axis_mirror);a.name = "axis_mirror";return a }
        lam = lambda {
            a = AxiStream.new(axis_mirror)
            unless axis_mirror[:name]
                a.name = "axis_mirror"
            end
            return a }
        hash.[]=(:axis_mirror,lam,false)
    end


    Tdl.module_stack  << lambda {
        hash.each do |k,v|
            if v.is_a? Proc
                hash.[]=(k,v.call,false)
            elsif v.is_a? Array
            #    unless v.empty?
            #        if v[0].is_a? Axi4
            #            cm = v[0].copy(name:k,idsize:Math.log2(v.length).ceil+v[0].idsize)
            #        else
            #            cm = v[0].copy(name:k)
            #        end
            #        cm.<<(*v)
            #        # hash[k] = cm
            #        hash.[]=(k,cm)
            #    else
            #        hash.[]=(k,nil,false)
            #    end
            else
                # hash[k] = v
            end
        end
        hash.check_use("axis_mirrors")
        AxiStream.axis_mirrors(hash)
    }
    return hash
end
inst_axis_pkt_fifo_filter_keep( depth:2 , axis_in:"axis_in", axis_out:"axis_out") click to toggle source
# File lib/tdl/axi_stream/bak/axis_pkt_fifo_filter_keep_auto.rb, line 100
def Tdl.inst_axis_pkt_fifo_filter_keep(
    depth:2   ,
    axis_in:"axis_in",
    axis_out:"axis_out")
    hash = TdlHash.new
    
    unless depth.is_a? Hash
        hash.case_record(:depth,depth)
    else
        # hash.new_index(:depth)= lambda { a = Parameter.new(depth);a.name = "depth";return a }
        # hash[:depth] = lambda { a = Parameter.new(depth);a.name = "depth";return a }
        raise TdlError.new('axis_pkt_fifo_filter_keep Parameter depth TdlHash cant include Proc') if depth.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(depth)
            unless depth[:name]
                a.name = "depth"
            end
            return a }
        hash.[]=(:depth,lam,false)
    end
            

    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('axis_pkt_fifo_filter_keep AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    unless axis_out.is_a? Hash
        hash.case_record(:axis_out,axis_out)
    else
        # hash.new_index(:axis_out)= lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        # hash[:axis_out] = lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        raise TdlError.new('axis_pkt_fifo_filter_keep AxiStream axis_out TdlHash cant include Proc') if axis_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_out)
            unless axis_out[:name]
                a.name = "axis_out"
            end
            return a }
        hash.[]=(:axis_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axis_pkt_fifo_filter_keep)
    hash.open_error = true
    return hash
end
inst_axis_ram_buffer( length:4096, wr_en:"wr_en", gen_en:"gen_en", gen_ready:"gen_ready", axis_wr_inf:"axis_wr_inf", axis_data_inf:"axis_data_inf") click to toggle source
# File lib/tdl/axi_stream/bak/axis_ram_buffer_auto.rb, line 106
def Tdl.inst_axis_ram_buffer(
    length:4096,
    wr_en:"wr_en",
    gen_en:"gen_en",
    gen_ready:"gen_ready",
    axis_wr_inf:"axis_wr_inf",
    axis_data_inf:"axis_data_inf")
    hash = TdlHash.new
    
    unless length.is_a? Hash
        hash.case_record(:length,length)
    else
        # hash.new_index(:length)= lambda { a = Parameter.new(length);a.name = "length";return a }
        # hash[:length] = lambda { a = Parameter.new(length);a.name = "length";return a }
        raise TdlError.new('axis_ram_buffer Parameter length TdlHash cant include Proc') if length.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(length)
            unless length[:name]
                a.name = "length"
            end
            return a }
        hash.[]=(:length,lam,false)
    end
            

    unless wr_en.is_a? Hash
        hash.case_record(:wr_en,wr_en)
    else
        # hash.new_index(:wr_en)= lambda { a = Logic.new(wr_en);a.name = "wr_en";return a }
        # hash[:wr_en] = lambda { a = Logic.new(wr_en);a.name = "wr_en";return a }
        raise TdlError.new('axis_ram_buffer Logic wr_en TdlHash cant include Proc') if wr_en.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(wr_en)
            unless wr_en[:name]
                a.name = "wr_en"
            end
            return a }
        hash.[]=(:wr_en,lam,false)
    end
            

    unless gen_en.is_a? Hash
        hash.case_record(:gen_en,gen_en)
    else
        # hash.new_index(:gen_en)= lambda { a = Logic.new(gen_en);a.name = "gen_en";return a }
        # hash[:gen_en] = lambda { a = Logic.new(gen_en);a.name = "gen_en";return a }
        raise TdlError.new('axis_ram_buffer Logic gen_en TdlHash cant include Proc') if gen_en.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(gen_en)
            unless gen_en[:name]
                a.name = "gen_en"
            end
            return a }
        hash.[]=(:gen_en,lam,false)
    end
            

    unless gen_ready.is_a? Hash
        hash.case_record(:gen_ready,gen_ready)
    else
        # hash.new_index(:gen_ready)= lambda { a = Logic.new(gen_ready);a.name = "gen_ready";return a }
        # hash[:gen_ready] = lambda { a = Logic.new(gen_ready);a.name = "gen_ready";return a }
        raise TdlError.new('axis_ram_buffer Logic gen_ready TdlHash cant include Proc') if gen_ready.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(gen_ready)
            unless gen_ready[:name]
                a.name = "gen_ready"
            end
            return a }
        hash.[]=(:gen_ready,lam,false)
    end
            

    unless axis_wr_inf.is_a? Hash
        hash.case_record(:axis_wr_inf,axis_wr_inf)
    else
        # hash.new_index(:axis_wr_inf)= lambda { a = AxiStream.new(axis_wr_inf);a.name = "axis_wr_inf";return a }
        # hash[:axis_wr_inf] = lambda { a = AxiStream.new(axis_wr_inf);a.name = "axis_wr_inf";return a }
        raise TdlError.new('axis_ram_buffer AxiStream axis_wr_inf TdlHash cant include Proc') if axis_wr_inf.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_wr_inf)
            unless axis_wr_inf[:name]
                a.name = "axis_wr_inf"
            end
            return a }
        hash.[]=(:axis_wr_inf,lam,false)
    end
            

    unless axis_data_inf.is_a? Hash
        hash.case_record(:axis_data_inf,axis_data_inf)
    else
        # hash.new_index(:axis_data_inf)= lambda { a = AxiStream.new(axis_data_inf);a.name = "axis_data_inf";return a }
        # hash[:axis_data_inf] = lambda { a = AxiStream.new(axis_data_inf);a.name = "axis_data_inf";return a }
        raise TdlError.new('axis_ram_buffer AxiStream axis_data_inf TdlHash cant include Proc') if axis_data_inf.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_data_inf)
            unless axis_data_inf[:name]
                a.name = "axis_data_inf"
            end
            return a }
        hash.[]=(:axis_data_inf,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axis_ram_buffer)
    hash.open_error = true
    return hash
end
inst_axis_slaver_empty( slaver:"slaver") click to toggle source
# File lib/tdl/axi_stream/bak/axis_slaver_empty_auto.rb, line 64
def Tdl.inst_axis_slaver_empty(
    slaver:"slaver")
    hash = TdlHash.new
    
    unless slaver.is_a? Hash
        hash.case_record(:slaver,slaver)
    else
        # hash.new_index(:slaver)= lambda { a = AxiStream.new(slaver);a.name = "slaver";return a }
        # hash[:slaver] = lambda { a = AxiStream.new(slaver);a.name = "slaver";return a }
        raise TdlError.new('axis_slaver_empty AxiStream slaver TdlHash cant include Proc') if slaver.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(slaver)
            unless slaver[:name]
                a.name = "slaver"
            end
            return a }
        hash.[]=(:slaver,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axis_slaver_empty)
    hash.open_error = true
    return hash
end
inst_axis_slaver_pipe( axis_in:"axis_in", axis_out:"axis_out") click to toggle source
# File lib/tdl/axi_stream/bak/axis_slaver_pipe_auto.rb, line 97
def Tdl.inst_axis_slaver_pipe(
    axis_in:"axis_in",
    axis_out:"axis_out")
    hash = TdlHash.new
    
    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('axis_slaver_pipe AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    unless axis_out.is_a? Hash
        hash.case_record(:axis_out,axis_out)
    else
        # hash.new_index(:axis_out)= lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        # hash[:axis_out] = lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        raise TdlError.new('axis_slaver_pipe AxiStream axis_out TdlHash cant include Proc') if axis_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_out)
            unless axis_out[:name]
                a.name = "axis_out"
            end
            return a }
        hash.[]=(:axis_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axis_slaver_pipe)
    hash.open_error = true
    return hash
end
inst_axis_slaver_pipe_a1( depth:1, axis_in:"axis_in", axis_out:"axis_out") click to toggle source
# File lib/tdl/axi_stream/bak/axis_slaver_pipe_A1_auto.rb, line 100
def Tdl.inst_axis_slaver_pipe_a1(
    depth:1,
    axis_in:"axis_in",
    axis_out:"axis_out")
    hash = TdlHash.new
    
    unless depth.is_a? Hash
        hash.case_record(:depth,depth)
    else
        # hash.new_index(:depth)= lambda { a = Parameter.new(depth);a.name = "depth";return a }
        # hash[:depth] = lambda { a = Parameter.new(depth);a.name = "depth";return a }
        raise TdlError.new('axis_slaver_pipe_a1 Parameter depth TdlHash cant include Proc') if depth.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(depth)
            unless depth[:name]
                a.name = "depth"
            end
            return a }
        hash.[]=(:depth,lam,false)
    end
            

    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('axis_slaver_pipe_a1 AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    unless axis_out.is_a? Hash
        hash.case_record(:axis_out,axis_out)
    else
        # hash.new_index(:axis_out)= lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        # hash[:axis_out] = lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        raise TdlError.new('axis_slaver_pipe_a1 AxiStream axis_out TdlHash cant include Proc') if axis_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_out)
            unless axis_out[:name]
                a.name = "axis_out"
            end
            return a }
        hash.[]=(:axis_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axis_slaver_pipe_a1)
    hash.open_error = true
    return hash
end
inst_axis_to_axi4_wr( addr:"addr", max_length:"max_length", axis_in:"axis_in", axi_wr:"axi_wr") click to toggle source
# File lib/tdl/axi4/bak/axis_to_axi4_wr_auto.rb, line 103
def Tdl.inst_axis_to_axi4_wr(
    addr:"addr",
    max_length:"max_length",
    axis_in:"axis_in",
    axi_wr:"axi_wr")
    hash = TdlHash.new
    
    unless addr.is_a? Hash
        hash.case_record(:addr,addr)
    else
        # hash.new_index(:addr)= lambda { a = Logic.new(addr);a.name = "addr";return a }
        # hash[:addr] = lambda { a = Logic.new(addr);a.name = "addr";return a }
        raise TdlError.new('axis_to_axi4_wr Logic addr TdlHash cant include Proc') if addr.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(addr)
            unless addr[:name]
                a.name = "addr"
            end
            return a }
        hash.[]=(:addr,lam,false)
    end
            

    unless max_length.is_a? Hash
        hash.case_record(:max_length,max_length)
    else
        # hash.new_index(:max_length)= lambda { a = Logic.new(max_length);a.name = "max_length";return a }
        # hash[:max_length] = lambda { a = Logic.new(max_length);a.name = "max_length";return a }
        raise TdlError.new('axis_to_axi4_wr Logic max_length TdlHash cant include Proc') if max_length.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(max_length)
            unless max_length[:name]
                a.name = "max_length"
            end
            return a }
        hash.[]=(:max_length,lam,false)
    end
            

    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('axis_to_axi4_wr AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    unless axi_wr.is_a? Hash
        hash.case_record(:axi_wr,axi_wr)
    else
        # hash.new_index(:axi_wr)= lambda { a = Axi4.new(axi_wr);a.name = "axi_wr";return a }
        # hash[:axi_wr] = lambda { a = Axi4.new(axi_wr);a.name = "axi_wr";return a }
        raise TdlError.new('axis_to_axi4_wr Axi4 axi_wr TdlHash cant include Proc') if axi_wr.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Axi4.new(axi_wr)
            unless axi_wr[:name]
                a.name = "axi_wr"
            end
            return a }
        hash.[]=(:axi_wr,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axis_to_axi4_wr)
    hash.open_error = true
    return hash
end
inst_axis_to_data_inf( data_out_inf:"data_out_inf", axis_in:"axis_in") click to toggle source
# File lib/tdl/axi_stream/bak/axis_to_data_inf_auto.rb, line 67
def Tdl.inst_axis_to_data_inf(
    data_out_inf:"data_out_inf",
    axis_in:"axis_in")
    hash = TdlHash.new
    
    unless data_out_inf.is_a? Hash
        hash.case_record(:data_out_inf,data_out_inf)
    else
        # hash.new_index(:data_out_inf)= lambda { a = DataInf_C.new(data_out_inf);a.name = "data_out_inf";return a }
        # hash[:data_out_inf] = lambda { a = DataInf_C.new(data_out_inf);a.name = "data_out_inf";return a }
        raise TdlError.new('axis_to_data_inf DataInf_C data_out_inf TdlHash cant include Proc') if data_out_inf.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf_C.new(data_out_inf)
            unless data_out_inf[:name]
                a.name = "data_out_inf"
            end
            return a }
        hash.[]=(:data_out_inf,lam,false)
    end
            

    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('axis_to_data_inf AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axis_to_data_inf)
    hash.open_error = true
    return hash
end
inst_axis_uncompress( asize:8, lsize:8, axis_zip:"axis_zip", axis_unzip:"axis_unzip") click to toggle source
# File lib/tdl/axi_stream/bak/axis_uncompress_auto.rb, line 72
def Tdl.inst_axis_uncompress(
    asize:8,
    lsize:8,
    axis_zip:"axis_zip",
    axis_unzip:"axis_unzip")
    hash = TdlHash.new
    
    unless asize.is_a? Hash
        hash.case_record(:asize,asize)
    else
        # hash.new_index(:asize)= lambda { a = Parameter.new(asize);a.name = "asize";return a }
        # hash[:asize] = lambda { a = Parameter.new(asize);a.name = "asize";return a }
        raise TdlError.new('axis_uncompress Parameter asize TdlHash cant include Proc') if asize.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(asize)
            unless asize[:name]
                a.name = "asize"
            end
            return a }
        hash.[]=(:asize,lam,false)
    end
            

    unless lsize.is_a? Hash
        hash.case_record(:lsize,lsize)
    else
        # hash.new_index(:lsize)= lambda { a = Parameter.new(lsize);a.name = "lsize";return a }
        # hash[:lsize] = lambda { a = Parameter.new(lsize);a.name = "lsize";return a }
        raise TdlError.new('axis_uncompress Parameter lsize TdlHash cant include Proc') if lsize.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(lsize)
            unless lsize[:name]
                a.name = "lsize"
            end
            return a }
        hash.[]=(:lsize,lam,false)
    end
            

    unless axis_zip.is_a? Hash
        hash.case_record(:axis_zip,axis_zip)
    else
        # hash.new_index(:axis_zip)= lambda { a = AxiStream.new(axis_zip);a.name = "axis_zip";return a }
        # hash[:axis_zip] = lambda { a = AxiStream.new(axis_zip);a.name = "axis_zip";return a }
        raise TdlError.new('axis_uncompress AxiStream axis_zip TdlHash cant include Proc') if axis_zip.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_zip)
            unless axis_zip[:name]
                a.name = "axis_zip"
            end
            return a }
        hash.[]=(:axis_zip,lam,false)
    end
            

    unless axis_unzip.is_a? Hash
        hash.case_record(:axis_unzip,axis_unzip)
    else
        # hash.new_index(:axis_unzip)= lambda { a = AxiStream.new(axis_unzip);a.name = "axis_unzip";return a }
        # hash[:axis_unzip] = lambda { a = AxiStream.new(axis_unzip);a.name = "axis_unzip";return a }
        raise TdlError.new('axis_uncompress AxiStream axis_unzip TdlHash cant include Proc') if axis_unzip.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_unzip)
            unless axis_unzip[:name]
                a.name = "axis_unzip"
            end
            return a }
        hash.[]=(:axis_unzip,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axis_uncompress)
    hash.open_error = true
    return hash
end
inst_axis_valve( button:"button", axis_in:"axis_in", axis_out:"axis_out") click to toggle source
# File lib/tdl/axi_stream/bak/axis_valve_auto.rb, line 99
def Tdl.inst_axis_valve(
    button:"button",
    axis_in:"axis_in",
    axis_out:"axis_out")
    hash = TdlHash.new
    
    unless button.is_a? Hash
        hash.case_record(:button,button)
    else
        # hash.new_index(:button)= lambda { a = Logic.new(button);a.name = "button";return a }
        # hash[:button] = lambda { a = Logic.new(button);a.name = "button";return a }
        raise TdlError.new('axis_valve Logic button TdlHash cant include Proc') if button.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(button)
            unless button[:name]
                a.name = "button"
            end
            return a }
        hash.[]=(:button,lam,false)
    end
            

    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('axis_valve AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    unless axis_out.is_a? Hash
        hash.case_record(:axis_out,axis_out)
    else
        # hash.new_index(:axis_out)= lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        # hash[:axis_out] = lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        raise TdlError.new('axis_valve AxiStream axis_out TdlHash cant include Proc') if axis_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_out)
            unless axis_out[:name]
                a.name = "axis_out"
            end
            return a }
        hash.[]=(:axis_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axis_valve)
    hash.open_error = true
    return hash
end
inst_axis_valve_with_pipe( button:"button", axis_in:"axis_in", axis_out:"axis_out") click to toggle source
# File lib/tdl/axi_stream/bak/axis_valve_with_pipe_auto.rb, line 99
def Tdl.inst_axis_valve_with_pipe(
    button:"button",
    axis_in:"axis_in",
    axis_out:"axis_out")
    hash = TdlHash.new
    
    unless button.is_a? Hash
        hash.case_record(:button,button)
    else
        # hash.new_index(:button)= lambda { a = Logic.new(button);a.name = "button";return a }
        # hash[:button] = lambda { a = Logic.new(button);a.name = "button";return a }
        raise TdlError.new('axis_valve_with_pipe Logic button TdlHash cant include Proc') if button.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(button)
            unless button[:name]
                a.name = "button"
            end
            return a }
        hash.[]=(:button,lam,false)
    end
            

    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('axis_valve_with_pipe AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    unless axis_out.is_a? Hash
        hash.case_record(:axis_out,axis_out)
    else
        # hash.new_index(:axis_out)= lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        # hash[:axis_out] = lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        raise TdlError.new('axis_valve_with_pipe AxiStream axis_out TdlHash cant include Proc') if axis_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_out)
            unless axis_out[:name]
                a.name = "axis_out"
            end
            return a }
        hash.[]=(:axis_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axis_valve_with_pipe)
    hash.open_error = true
    return hash
end
inst_axis_width_combin( slim_axis:"slim_axis", wide_axis:"wide_axis") click to toggle source
# File lib/tdl/axi_stream/bak/axis_width_combin_auto.rb, line 97
def Tdl.inst_axis_width_combin(
    slim_axis:"slim_axis",
    wide_axis:"wide_axis")
    hash = TdlHash.new
    
    unless slim_axis.is_a? Hash
        hash.case_record(:slim_axis,slim_axis)
    else
        # hash.new_index(:slim_axis)= lambda { a = AxiStream.new(slim_axis);a.name = "slim_axis";return a }
        # hash[:slim_axis] = lambda { a = AxiStream.new(slim_axis);a.name = "slim_axis";return a }
        raise TdlError.new('axis_width_combin AxiStream slim_axis TdlHash cant include Proc') if slim_axis.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(slim_axis)
            unless slim_axis[:name]
                a.name = "slim_axis"
            end
            return a }
        hash.[]=(:slim_axis,lam,false)
    end
            

    unless wide_axis.is_a? Hash
        hash.case_record(:wide_axis,wide_axis)
    else
        # hash.new_index(:wide_axis)= lambda { a = AxiStream.new(wide_axis);a.name = "wide_axis";return a }
        # hash[:wide_axis] = lambda { a = AxiStream.new(wide_axis);a.name = "wide_axis";return a }
        raise TdlError.new('axis_width_combin AxiStream wide_axis TdlHash cant include Proc') if wide_axis.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(wide_axis)
            unless wide_axis[:name]
                a.name = "wide_axis"
            end
            return a }
        hash.[]=(:wide_axis,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axis_width_combin)
    hash.open_error = true
    return hash
end
inst_axis_width_convert( in_axis:"in_axis", out_axis:"out_axis") click to toggle source
# File lib/tdl/axi_stream/bak/axis_width_convert_auto.rb, line 97
def Tdl.inst_axis_width_convert(
    in_axis:"in_axis",
    out_axis:"out_axis")
    hash = TdlHash.new
    
    unless in_axis.is_a? Hash
        hash.case_record(:in_axis,in_axis)
    else
        # hash.new_index(:in_axis)= lambda { a = AxiStream.new(in_axis);a.name = "in_axis";return a }
        # hash[:in_axis] = lambda { a = AxiStream.new(in_axis);a.name = "in_axis";return a }
        raise TdlError.new('axis_width_convert AxiStream in_axis TdlHash cant include Proc') if in_axis.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(in_axis)
            unless in_axis[:name]
                a.name = "in_axis"
            end
            return a }
        hash.[]=(:in_axis,lam,false)
    end
            

    unless out_axis.is_a? Hash
        hash.case_record(:out_axis,out_axis)
    else
        # hash.new_index(:out_axis)= lambda { a = AxiStream.new(out_axis);a.name = "out_axis";return a }
        # hash[:out_axis] = lambda { a = AxiStream.new(out_axis);a.name = "out_axis";return a }
        raise TdlError.new('axis_width_convert AxiStream out_axis TdlHash cant include Proc') if out_axis.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(out_axis)
            unless out_axis[:name]
                a.name = "out_axis"
            end
            return a }
        hash.[]=(:out_axis,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axis_width_convert)
    hash.open_error = true
    return hash
end
inst_axis_width_destruct( wide_axis:"wide_axis", slim_axis:"slim_axis") click to toggle source
# File lib/tdl/axi_stream/bak/axis_width_destruct_auto.rb, line 97
def Tdl.inst_axis_width_destruct(
    wide_axis:"wide_axis",
    slim_axis:"slim_axis")
    hash = TdlHash.new
    
    unless wide_axis.is_a? Hash
        hash.case_record(:wide_axis,wide_axis)
    else
        # hash.new_index(:wide_axis)= lambda { a = AxiStream.new(wide_axis);a.name = "wide_axis";return a }
        # hash[:wide_axis] = lambda { a = AxiStream.new(wide_axis);a.name = "wide_axis";return a }
        raise TdlError.new('axis_width_destruct AxiStream wide_axis TdlHash cant include Proc') if wide_axis.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(wide_axis)
            unless wide_axis[:name]
                a.name = "wide_axis"
            end
            return a }
        hash.[]=(:wide_axis,lam,false)
    end
            

    unless slim_axis.is_a? Hash
        hash.case_record(:slim_axis,slim_axis)
    else
        # hash.new_index(:slim_axis)= lambda { a = AxiStream.new(slim_axis);a.name = "slim_axis";return a }
        # hash[:slim_axis] = lambda { a = AxiStream.new(slim_axis);a.name = "slim_axis";return a }
        raise TdlError.new('axis_width_destruct AxiStream slim_axis TdlHash cant include Proc') if slim_axis.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(slim_axis)
            unless slim_axis[:name]
                a.name = "slim_axis"
            end
            return a }
        hash.[]=(:slim_axis,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:axis_width_destruct)
    hash.open_error = true
    return hash
end
inst_axis_wrapper_oled(oled_sdin:"oled_sdin",oled_sclk:"oled_sclk",oled_dc:"oled_dc",oled_res:"oled_res",oled_vbat:"oled_vbat",oled_vdd:"oled_vdd",trigger_toggle:"trigger_toggle",lite_ctrl_inf:"lite_ctrl_inf",ctrl_inf:"ctrl_inf") click to toggle source
# File lib/tdl/axi_stream/bak/axis_wrapper_oled_auto.rb, line 75
def self.inst_axis_wrapper_oled(oled_sdin:"oled_sdin",oled_sclk:"oled_sclk",oled_dc:"oled_dc",oled_res:"oled_res",oled_vbat:"oled_vbat",oled_vdd:"oled_vdd",trigger_toggle:"trigger_toggle",lite_ctrl_inf:"lite_ctrl_inf",ctrl_inf:"ctrl_inf")
    hash = TdlHash.new
    
    unless oled_sdin.is_a? Hash
        # hash.new_index(:oled_sdin) = oled_sdin
        if oled_sdin.is_a? InfElm
            hash.[]=(:oled_sdin,oled_sdin,true)
        else
            hash.[]=(:oled_sdin,oled_sdin,false)
        end
    else
        # hash.new_index(:oled_sdin)= lambda { a = Logic.new(oled_sdin);a.name = "oled_sdin";return a }
        # hash[:oled_sdin] = lambda { a = Logic.new(oled_sdin);a.name = "oled_sdin";return a }
        hash.[]=(:oled_sdin,lambda { a = Logic.new(oled_sdin);a.name = "oled_sdin";return a },false)
    end
            

    unless oled_sclk.is_a? Hash
        # hash.new_index(:oled_sclk) = oled_sclk
        if oled_sclk.is_a? InfElm
            hash.[]=(:oled_sclk,oled_sclk,true)
        else
            hash.[]=(:oled_sclk,oled_sclk,false)
        end
    else
        # hash.new_index(:oled_sclk)= lambda { a = Logic.new(oled_sclk);a.name = "oled_sclk";return a }
        # hash[:oled_sclk] = lambda { a = Logic.new(oled_sclk);a.name = "oled_sclk";return a }
        hash.[]=(:oled_sclk,lambda { a = Logic.new(oled_sclk);a.name = "oled_sclk";return a },false)
    end
            

    unless oled_dc.is_a? Hash
        # hash.new_index(:oled_dc) = oled_dc
        if oled_dc.is_a? InfElm
            hash.[]=(:oled_dc,oled_dc,true)
        else
            hash.[]=(:oled_dc,oled_dc,false)
        end
    else
        # hash.new_index(:oled_dc)= lambda { a = Logic.new(oled_dc);a.name = "oled_dc";return a }
        # hash[:oled_dc] = lambda { a = Logic.new(oled_dc);a.name = "oled_dc";return a }
        hash.[]=(:oled_dc,lambda { a = Logic.new(oled_dc);a.name = "oled_dc";return a },false)
    end
            

    unless oled_res.is_a? Hash
        # hash.new_index(:oled_res) = oled_res
        if oled_res.is_a? InfElm
            hash.[]=(:oled_res,oled_res,true)
        else
            hash.[]=(:oled_res,oled_res,false)
        end
    else
        # hash.new_index(:oled_res)= lambda { a = Logic.new(oled_res);a.name = "oled_res";return a }
        # hash[:oled_res] = lambda { a = Logic.new(oled_res);a.name = "oled_res";return a }
        hash.[]=(:oled_res,lambda { a = Logic.new(oled_res);a.name = "oled_res";return a },false)
    end
            

    unless oled_vbat.is_a? Hash
        # hash.new_index(:oled_vbat) = oled_vbat
        if oled_vbat.is_a? InfElm
            hash.[]=(:oled_vbat,oled_vbat,true)
        else
            hash.[]=(:oled_vbat,oled_vbat,false)
        end
    else
        # hash.new_index(:oled_vbat)= lambda { a = Logic.new(oled_vbat);a.name = "oled_vbat";return a }
        # hash[:oled_vbat] = lambda { a = Logic.new(oled_vbat);a.name = "oled_vbat";return a }
        hash.[]=(:oled_vbat,lambda { a = Logic.new(oled_vbat);a.name = "oled_vbat";return a },false)
    end
            

    unless oled_vdd.is_a? Hash
        # hash.new_index(:oled_vdd) = oled_vdd
        if oled_vdd.is_a? InfElm
            hash.[]=(:oled_vdd,oled_vdd,true)
        else
            hash.[]=(:oled_vdd,oled_vdd,false)
        end
    else
        # hash.new_index(:oled_vdd)= lambda { a = Logic.new(oled_vdd);a.name = "oled_vdd";return a }
        # hash[:oled_vdd] = lambda { a = Logic.new(oled_vdd);a.name = "oled_vdd";return a }
        hash.[]=(:oled_vdd,lambda { a = Logic.new(oled_vdd);a.name = "oled_vdd";return a },false)
    end
            

    unless trigger_toggle.is_a? Hash
        # hash.new_index(:trigger_toggle) = trigger_toggle
        if trigger_toggle.is_a? InfElm
            hash.[]=(:trigger_toggle,trigger_toggle,true)
        else
            hash.[]=(:trigger_toggle,trigger_toggle,false)
        end
    else
        # hash.new_index(:trigger_toggle)= lambda { a = Logic.new(trigger_toggle);a.name = "trigger_toggle";return a }
        # hash[:trigger_toggle] = lambda { a = Logic.new(trigger_toggle);a.name = "trigger_toggle";return a }
        hash.[]=(:trigger_toggle,lambda { a = Logic.new(trigger_toggle);a.name = "trigger_toggle";return a },false)
    end
            

    unless lite_ctrl_inf.is_a? Hash
        # hash.new_index(:lite_ctrl_inf) = lite_ctrl_inf
        if lite_ctrl_inf.is_a? InfElm
            hash.[]=(:lite_ctrl_inf,lite_ctrl_inf,true)
        else
            hash.[]=(:lite_ctrl_inf,lite_ctrl_inf,false)
        end
    else
        # hash.new_index(:lite_ctrl_inf)= lambda { a = AxiLite.new(lite_ctrl_inf);a.name = "lite_ctrl_inf";return a }
        # hash[:lite_ctrl_inf] = lambda { a = AxiLite.new(lite_ctrl_inf);a.name = "lite_ctrl_inf";return a }
        hash.[]=(:lite_ctrl_inf,lambda { a = AxiLite.new(lite_ctrl_inf);a.name = "lite_ctrl_inf";return a },false)
    end
            

    unless ctrl_inf.is_a? Hash
        # hash.new_index(:ctrl_inf) = ctrl_inf
        if ctrl_inf.is_a? InfElm
            hash.[]=(:ctrl_inf,ctrl_inf,true)
        else
            hash.[]=(:ctrl_inf,ctrl_inf,false)
        end
    else
        # hash.new_index(:ctrl_inf)= lambda { a = AxiStream.new(ctrl_inf);a.name = "ctrl_inf";return a }
        # hash[:ctrl_inf] = lambda { a = AxiStream.new(ctrl_inf);a.name = "ctrl_inf";return a }
        hash.[]=(:ctrl_inf,lambda { a = AxiStream.new(ctrl_inf);a.name = "ctrl_inf";return a },false)
    end
            

    Tdl.module_stack  << lambda {
        hash.each do |k,v|
            if v.is_a? Proc
                hash.[]=(k,v.call,false)
            elsif v.is_a? Array
                unless v.empty?
                    if v[0].is_a? Axi4
                        cm = v[0].copy(name:k,idsize:Math.log2(v.length).ceil+v[0].idsize)
                    else
                        cm = v[0].copy(name:k)
                    end
                    cm.<<(*v)
                    # hash[k] = cm
                    hash.[]=(k,cm)
                else
                    hash.[]=(k,nil,false)
                end
            else
                # hash[k] = v
            end
        end
        hash.check_use("axis_wrapper_oled")
        AxiLite.axis_wrapper_oled(hash)
    }
    return hash
end
inst_check_stream_crc( axis_in:"axis_in") click to toggle source
# File lib/tdl/axi_stream/bak/check_stream_crc_auto.rb, line 64
def Tdl.inst_check_stream_crc(
    axis_in:"axis_in")
    hash = TdlHash.new
    
    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('check_stream_crc AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:check_stream_crc)
    hash.open_error = true
    return hash
end
inst_common_fifo( depth:4, dsize:8, clock:"clock", rst_n:"rst_n", wdata:"wdata", wr_en:"wr_en", rdata:"rdata", rd_en:"rd_en", count:"count", empty:"empty", full:"full") click to toggle source
# File lib/tdl/data_inf/bak/common_fifo_auto.rb, line 85
def Tdl.inst_common_fifo(
    depth:4,
    dsize:8,
    clock:"clock",
    rst_n:"rst_n",
    wdata:"wdata",
    wr_en:"wr_en",
    rdata:"rdata",
    rd_en:"rd_en",
    count:"count",
    empty:"empty",
    full:"full")
    hash = TdlHash.new
    
    unless depth.is_a? Hash
        hash.case_record(:depth,depth)
    else
        # hash.new_index(:depth)= lambda { a = Parameter.new(depth);a.name = "depth";return a }
        # hash[:depth] = lambda { a = Parameter.new(depth);a.name = "depth";return a }
        raise TdlError.new('common_fifo Parameter depth TdlHash cant include Proc') if depth.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(depth)
            unless depth[:name]
                a.name = "depth"
            end
            return a }
        hash.[]=(:depth,lam,false)
    end
            

    unless dsize.is_a? Hash
        hash.case_record(:dsize,dsize)
    else
        # hash.new_index(:dsize)= lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        # hash[:dsize] = lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        raise TdlError.new('common_fifo Parameter dsize TdlHash cant include Proc') if dsize.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(dsize)
            unless dsize[:name]
                a.name = "dsize"
            end
            return a }
        hash.[]=(:dsize,lam,false)
    end
            

    unless clock.is_a? Hash
        hash.case_record(:clock,clock)
    else
        # hash.new_index(:clock)= lambda { a = Logic.new(clock);a.name = "clock";return a }
        # hash[:clock] = lambda { a = Logic.new(clock);a.name = "clock";return a }
        raise TdlError.new('common_fifo Logic clock TdlHash cant include Proc') if clock.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(clock)
            unless clock[:name]
                a.name = "clock"
            end
            return a }
        hash.[]=(:clock,lam,false)
    end
            

    unless rst_n.is_a? Hash
        hash.case_record(:rst_n,rst_n)
    else
        # hash.new_index(:rst_n)= lambda { a = Logic.new(rst_n);a.name = "rst_n";return a }
        # hash[:rst_n] = lambda { a = Logic.new(rst_n);a.name = "rst_n";return a }
        raise TdlError.new('common_fifo Logic rst_n TdlHash cant include Proc') if rst_n.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(rst_n)
            unless rst_n[:name]
                a.name = "rst_n"
            end
            return a }
        hash.[]=(:rst_n,lam,false)
    end
            

    unless wdata.is_a? Hash
        hash.case_record(:wdata,wdata)
    else
        # hash.new_index(:wdata)= lambda { a = Logic.new(wdata);a.name = "wdata";return a }
        # hash[:wdata] = lambda { a = Logic.new(wdata);a.name = "wdata";return a }
        raise TdlError.new('common_fifo Logic wdata TdlHash cant include Proc') if wdata.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(wdata)
            unless wdata[:name]
                a.name = "wdata"
            end
            return a }
        hash.[]=(:wdata,lam,false)
    end
            

    unless wr_en.is_a? Hash
        hash.case_record(:wr_en,wr_en)
    else
        # hash.new_index(:wr_en)= lambda { a = Logic.new(wr_en);a.name = "wr_en";return a }
        # hash[:wr_en] = lambda { a = Logic.new(wr_en);a.name = "wr_en";return a }
        raise TdlError.new('common_fifo Logic wr_en TdlHash cant include Proc') if wr_en.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(wr_en)
            unless wr_en[:name]
                a.name = "wr_en"
            end
            return a }
        hash.[]=(:wr_en,lam,false)
    end
            

    unless rdata.is_a? Hash
        hash.case_record(:rdata,rdata)
    else
        # hash.new_index(:rdata)= lambda { a = Logic.new(rdata);a.name = "rdata";return a }
        # hash[:rdata] = lambda { a = Logic.new(rdata);a.name = "rdata";return a }
        raise TdlError.new('common_fifo Logic rdata TdlHash cant include Proc') if rdata.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(rdata)
            unless rdata[:name]
                a.name = "rdata"
            end
            return a }
        hash.[]=(:rdata,lam,false)
    end
            

    unless rd_en.is_a? Hash
        hash.case_record(:rd_en,rd_en)
    else
        # hash.new_index(:rd_en)= lambda { a = Logic.new(rd_en);a.name = "rd_en";return a }
        # hash[:rd_en] = lambda { a = Logic.new(rd_en);a.name = "rd_en";return a }
        raise TdlError.new('common_fifo Logic rd_en TdlHash cant include Proc') if rd_en.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(rd_en)
            unless rd_en[:name]
                a.name = "rd_en"
            end
            return a }
        hash.[]=(:rd_en,lam,false)
    end
            

    unless count.is_a? Hash
        hash.case_record(:count,count)
    else
        # hash.new_index(:count)= lambda { a = Logic.new(count);a.name = "count";return a }
        # hash[:count] = lambda { a = Logic.new(count);a.name = "count";return a }
        raise TdlError.new('common_fifo Logic count TdlHash cant include Proc') if count.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(count)
            unless count[:name]
                a.name = "count"
            end
            return a }
        hash.[]=(:count,lam,false)
    end
            

    unless empty.is_a? Hash
        hash.case_record(:empty,empty)
    else
        # hash.new_index(:empty)= lambda { a = Logic.new(empty);a.name = "empty";return a }
        # hash[:empty] = lambda { a = Logic.new(empty);a.name = "empty";return a }
        raise TdlError.new('common_fifo Logic empty TdlHash cant include Proc') if empty.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(empty)
            unless empty[:name]
                a.name = "empty"
            end
            return a }
        hash.[]=(:empty,lam,false)
    end
            

    unless full.is_a? Hash
        hash.case_record(:full,full)
    else
        # hash.new_index(:full)= lambda { a = Logic.new(full);a.name = "full";return a }
        # hash[:full] = lambda { a = Logic.new(full);a.name = "full";return a }
        raise TdlError.new('common_fifo Logic full TdlHash cant include Proc') if full.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(full)
            unless full[:name]
                a.name = "full"
            end
            return a }
        hash.[]=(:full,lam,false)
    end
            

    hash.push_to_module_stack(DataInf,:common_fifo)
    hash.open_error = true
    return hash
end
inst_data_bind( num:2, data_in:"data_in", data_out:"data_out") click to toggle source
# File lib/tdl/data_inf/bak/data_bind_auto.rb, line 70
def Tdl.inst_data_bind(
    num:2,
    data_in:"data_in",
    data_out:"data_out")
    hash = TdlHash.new
    
    unless num.is_a? Hash
        hash.case_record(:num,num)
    else
        # hash.new_index(:num)= lambda { a = Parameter.new(num);a.name = "num";return a }
        # hash[:num] = lambda { a = Parameter.new(num);a.name = "num";return a }
        raise TdlError.new('data_bind Parameter num TdlHash cant include Proc') if num.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(num)
            unless num[:name]
                a.name = "num"
            end
            return a }
        hash.[]=(:num,lam,false)
    end
            

    unless data_in.is_a? Hash
        hash.case_record(:data_in,data_in)
    else
        # hash.new_index(:data_in)= lambda { a = DataInf_C.new(data_in);a.name = "data_in";return a }
        # hash[:data_in] = lambda { a = DataInf_C.new(data_in);a.name = "data_in";return a }
        raise TdlError.new('data_bind DataInf_C data_in TdlHash cant include Proc') if data_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf_C.new(data_in)
            unless data_in[:name]
                a.name = "data_in"
            end
            return a }
        hash.[]=(:data_in,lam,false)
    end
            

    unless data_out.is_a? Hash
        hash.case_record(:data_out,data_out)
    else
        # hash.new_index(:data_out)= lambda { a = DataInf_C.new(data_out);a.name = "data_out";return a }
        # hash[:data_out] = lambda { a = DataInf_C.new(data_out);a.name = "data_out";return a }
        raise TdlError.new('data_bind DataInf_C data_out TdlHash cant include Proc') if data_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf_C.new(data_out)
            unless data_out[:name]
                a.name = "data_out"
            end
            return a }
        hash.[]=(:data_out,lam,false)
    end
            

    hash.push_to_module_stack(DataInf_C,:data_bind)
    hash.open_error = true
    return hash
end
inst_data_c_direct( slaver:"slaver", master:"master") click to toggle source
# File lib/tdl/data_inf/bak/data_c_direct_auto.rb, line 97
def Tdl.inst_data_c_direct(
    slaver:"slaver",
    master:"master")
    hash = TdlHash.new
    
    unless slaver.is_a? Hash
        hash.case_record(:slaver,slaver)
    else
        # hash.new_index(:slaver)= lambda { a = DataInf_C.new(slaver);a.name = "slaver";return a }
        # hash[:slaver] = lambda { a = DataInf_C.new(slaver);a.name = "slaver";return a }
        raise TdlError.new('data_c_direct DataInf_C slaver TdlHash cant include Proc') if slaver.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf_C.new(slaver)
            unless slaver[:name]
                a.name = "slaver"
            end
            return a }
        hash.[]=(:slaver,lam,false)
    end
            

    unless master.is_a? Hash
        hash.case_record(:master,master)
    else
        # hash.new_index(:master)= lambda { a = DataInf_C.new(master);a.name = "master";return a }
        # hash[:master] = lambda { a = DataInf_C.new(master);a.name = "master";return a }
        raise TdlError.new('data_c_direct DataInf_C master TdlHash cant include Proc') if master.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf_C.new(master)
            unless master[:name]
                a.name = "master"
            end
            return a }
        hash.[]=(:master,lam,false)
    end
            

    hash.push_to_module_stack(DataInf_C,:data_c_direct)
    hash.open_error = true
    return hash
end
inst_data_c_direct_mirror( slaver:"slaver", master:"master") click to toggle source
# File lib/tdl/data_inf/bak/data_c_direct_mirror_auto.rb, line 97
def Tdl.inst_data_c_direct_mirror(
    slaver:"slaver",
    master:"master")
    hash = TdlHash.new
    
    unless slaver.is_a? Hash
        hash.case_record(:slaver,slaver)
    else
        # hash.new_index(:slaver)= lambda { a = DataInf_C.new(slaver);a.name = "slaver";return a }
        # hash[:slaver] = lambda { a = DataInf_C.new(slaver);a.name = "slaver";return a }
        raise TdlError.new('data_c_direct_mirror DataInf_C slaver TdlHash cant include Proc') if slaver.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf_C.new(slaver)
            unless slaver[:name]
                a.name = "slaver"
            end
            return a }
        hash.[]=(:slaver,lam,false)
    end
            

    unless master.is_a? Hash
        hash.case_record(:master,master)
    else
        # hash.new_index(:master)= lambda { a = DataInf_C.new(master);a.name = "master";return a }
        # hash[:master] = lambda { a = DataInf_C.new(master);a.name = "master";return a }
        raise TdlError.new('data_c_direct_mirror DataInf_C master TdlHash cant include Proc') if master.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf_C.new(master)
            unless master[:name]
                a.name = "master"
            end
            return a }
        hash.[]=(:master,lam,false)
    end
            

    hash.push_to_module_stack(DataInf_C,:data_c_direct_mirror)
    hash.open_error = true
    return hash
end
inst_data_c_tmp_cache( slaver:"slaver", master:"master") click to toggle source
# File lib/tdl/data_inf/bak/data_c_tmp_cache_auto.rb, line 97
def Tdl.inst_data_c_tmp_cache(
    slaver:"slaver",
    master:"master")
    hash = TdlHash.new
    
    unless slaver.is_a? Hash
        hash.case_record(:slaver,slaver)
    else
        # hash.new_index(:slaver)= lambda { a = DataInf_C.new(slaver);a.name = "slaver";return a }
        # hash[:slaver] = lambda { a = DataInf_C.new(slaver);a.name = "slaver";return a }
        raise TdlError.new('data_c_tmp_cache DataInf_C slaver TdlHash cant include Proc') if slaver.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf_C.new(slaver)
            unless slaver[:name]
                a.name = "slaver"
            end
            return a }
        hash.[]=(:slaver,lam,false)
    end
            

    unless master.is_a? Hash
        hash.case_record(:master,master)
    else
        # hash.new_index(:master)= lambda { a = DataInf_C.new(master);a.name = "master";return a }
        # hash[:master] = lambda { a = DataInf_C.new(master);a.name = "master";return a }
        raise TdlError.new('data_c_tmp_cache DataInf_C master TdlHash cant include Proc') if master.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf_C.new(master)
            unless master[:name]
                a.name = "master"
            end
            return a }
        hash.[]=(:master,lam,false)
    end
            

    hash.push_to_module_stack(DataInf_C,:data_c_tmp_cache)
    hash.open_error = true
    return hash
end
inst_data_condition_mirror( h:0, l:0, condition_data:"condition_data", data_in:"data_in", data_out:"data_out", data_mirror:"data_mirror") click to toggle source
# File lib/tdl/data_inf/bak/data_condition_mirror_auto.rb, line 107
def Tdl.inst_data_condition_mirror(
    h:0,
    l:0,
    condition_data:"condition_data",
    data_in:"data_in",
    data_out:"data_out",
    data_mirror:"data_mirror")
    hash = TdlHash.new
    
    unless h.is_a? Hash
        hash.case_record(:h,h)
    else
        # hash.new_index(:h)= lambda { a = Parameter.new(h);a.name = "h";return a }
        # hash[:h] = lambda { a = Parameter.new(h);a.name = "h";return a }
        raise TdlError.new('data_condition_mirror Parameter h TdlHash cant include Proc') if h.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(h)
            unless h[:name]
                a.name = "h"
            end
            return a }
        hash.[]=(:h,lam,false)
    end
            

    unless l.is_a? Hash
        hash.case_record(:l,l)
    else
        # hash.new_index(:l)= lambda { a = Parameter.new(l);a.name = "l";return a }
        # hash[:l] = lambda { a = Parameter.new(l);a.name = "l";return a }
        raise TdlError.new('data_condition_mirror Parameter l TdlHash cant include Proc') if l.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(l)
            unless l[:name]
                a.name = "l"
            end
            return a }
        hash.[]=(:l,lam,false)
    end
            

    unless condition_data.is_a? Hash
        hash.case_record(:condition_data,condition_data)
    else
        # hash.new_index(:condition_data)= lambda { a = Logic.new(condition_data);a.name = "condition_data";return a }
        # hash[:condition_data] = lambda { a = Logic.new(condition_data);a.name = "condition_data";return a }
        raise TdlError.new('data_condition_mirror Logic condition_data TdlHash cant include Proc') if condition_data.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(condition_data)
            unless condition_data[:name]
                a.name = "condition_data"
            end
            return a }
        hash.[]=(:condition_data,lam,false)
    end
            

    unless data_in.is_a? Hash
        hash.case_record(:data_in,data_in)
    else
        # hash.new_index(:data_in)= lambda { a = DataInf_C.new(data_in);a.name = "data_in";return a }
        # hash[:data_in] = lambda { a = DataInf_C.new(data_in);a.name = "data_in";return a }
        raise TdlError.new('data_condition_mirror DataInf_C data_in TdlHash cant include Proc') if data_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf_C.new(data_in)
            unless data_in[:name]
                a.name = "data_in"
            end
            return a }
        hash.[]=(:data_in,lam,false)
    end
            

    unless data_out.is_a? Hash
        hash.case_record(:data_out,data_out)
    else
        # hash.new_index(:data_out)= lambda { a = DataInf_C.new(data_out);a.name = "data_out";return a }
        # hash[:data_out] = lambda { a = DataInf_C.new(data_out);a.name = "data_out";return a }
        raise TdlError.new('data_condition_mirror DataInf_C data_out TdlHash cant include Proc') if data_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf_C.new(data_out)
            unless data_out[:name]
                a.name = "data_out"
            end
            return a }
        hash.[]=(:data_out,lam,false)
    end
            

    unless data_mirror.is_a? Hash
        hash.case_record(:data_mirror,data_mirror)
    else
        # hash.new_index(:data_mirror)= lambda { a = DataInf_C.new(data_mirror);a.name = "data_mirror";return a }
        # hash[:data_mirror] = lambda { a = DataInf_C.new(data_mirror);a.name = "data_mirror";return a }
        raise TdlError.new('data_condition_mirror DataInf_C data_mirror TdlHash cant include Proc') if data_mirror.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf_C.new(data_mirror)
            unless data_mirror[:name]
                a.name = "data_mirror"
            end
            return a }
        hash.[]=(:data_mirror,lam,false)
    end
            

    hash.push_to_module_stack(DataInf_C,:data_condition_mirror)
    hash.open_error = true
    return hash
end
inst_data_condition_valve( h:0, l:0, condition_button:"condition_button", condition_data:"condition_data", data_in:"data_in", data_out:"data_out") click to toggle source
# File lib/tdl/data_inf/bak/data_condition_valve_auto.rb, line 106
def Tdl.inst_data_condition_valve(
    h:0,
    l:0,
    condition_button:"condition_button",
    condition_data:"condition_data",
    data_in:"data_in",
    data_out:"data_out")
    hash = TdlHash.new
    
    unless h.is_a? Hash
        hash.case_record(:h,h)
    else
        # hash.new_index(:h)= lambda { a = Parameter.new(h);a.name = "h";return a }
        # hash[:h] = lambda { a = Parameter.new(h);a.name = "h";return a }
        raise TdlError.new('data_condition_valve Parameter h TdlHash cant include Proc') if h.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(h)
            unless h[:name]
                a.name = "h"
            end
            return a }
        hash.[]=(:h,lam,false)
    end
            

    unless l.is_a? Hash
        hash.case_record(:l,l)
    else
        # hash.new_index(:l)= lambda { a = Parameter.new(l);a.name = "l";return a }
        # hash[:l] = lambda { a = Parameter.new(l);a.name = "l";return a }
        raise TdlError.new('data_condition_valve Parameter l TdlHash cant include Proc') if l.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(l)
            unless l[:name]
                a.name = "l"
            end
            return a }
        hash.[]=(:l,lam,false)
    end
            

    unless condition_button.is_a? Hash
        hash.case_record(:condition_button,condition_button)
    else
        # hash.new_index(:condition_button)= lambda { a = Logic.new(condition_button);a.name = "condition_button";return a }
        # hash[:condition_button] = lambda { a = Logic.new(condition_button);a.name = "condition_button";return a }
        raise TdlError.new('data_condition_valve Logic condition_button TdlHash cant include Proc') if condition_button.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(condition_button)
            unless condition_button[:name]
                a.name = "condition_button"
            end
            return a }
        hash.[]=(:condition_button,lam,false)
    end
            

    unless condition_data.is_a? Hash
        hash.case_record(:condition_data,condition_data)
    else
        # hash.new_index(:condition_data)= lambda { a = Logic.new(condition_data);a.name = "condition_data";return a }
        # hash[:condition_data] = lambda { a = Logic.new(condition_data);a.name = "condition_data";return a }
        raise TdlError.new('data_condition_valve Logic condition_data TdlHash cant include Proc') if condition_data.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(condition_data)
            unless condition_data[:name]
                a.name = "condition_data"
            end
            return a }
        hash.[]=(:condition_data,lam,false)
    end
            

    unless data_in.is_a? Hash
        hash.case_record(:data_in,data_in)
    else
        # hash.new_index(:data_in)= lambda { a = DataInf_C.new(data_in);a.name = "data_in";return a }
        # hash[:data_in] = lambda { a = DataInf_C.new(data_in);a.name = "data_in";return a }
        raise TdlError.new('data_condition_valve DataInf_C data_in TdlHash cant include Proc') if data_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf_C.new(data_in)
            unless data_in[:name]
                a.name = "data_in"
            end
            return a }
        hash.[]=(:data_in,lam,false)
    end
            

    unless data_out.is_a? Hash
        hash.case_record(:data_out,data_out)
    else
        # hash.new_index(:data_out)= lambda { a = DataInf_C.new(data_out);a.name = "data_out";return a }
        # hash[:data_out] = lambda { a = DataInf_C.new(data_out);a.name = "data_out";return a }
        raise TdlError.new('data_condition_valve DataInf_C data_out TdlHash cant include Proc') if data_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf_C.new(data_out)
            unless data_out[:name]
                a.name = "data_out"
            end
            return a }
        hash.[]=(:data_out,lam,false)
    end
            

    hash.push_to_module_stack(DataInf_C,:data_condition_valve)
    hash.open_error = true
    return hash
end
inst_data_connect_pipe_inf( indata:"indata", outdata:"outdata") click to toggle source
# File lib/tdl/data_inf/bak/data_connect_pipe_inf_auto.rb, line 97
def Tdl.inst_data_connect_pipe_inf(
    indata:"indata",
    outdata:"outdata")
    hash = TdlHash.new
    
    unless indata.is_a? Hash
        hash.case_record(:indata,indata)
    else
        # hash.new_index(:indata)= lambda { a = DataInf_C.new(indata);a.name = "indata";return a }
        # hash[:indata] = lambda { a = DataInf_C.new(indata);a.name = "indata";return a }
        raise TdlError.new('data_connect_pipe_inf DataInf_C indata TdlHash cant include Proc') if indata.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf_C.new(indata)
            unless indata[:name]
                a.name = "indata"
            end
            return a }
        hash.[]=(:indata,lam,false)
    end
            

    unless outdata.is_a? Hash
        hash.case_record(:outdata,outdata)
    else
        # hash.new_index(:outdata)= lambda { a = DataInf_C.new(outdata);a.name = "outdata";return a }
        # hash[:outdata] = lambda { a = DataInf_C.new(outdata);a.name = "outdata";return a }
        raise TdlError.new('data_connect_pipe_inf DataInf_C outdata TdlHash cant include Proc') if outdata.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf_C.new(outdata)
            unless outdata[:name]
                a.name = "outdata"
            end
            return a }
        hash.[]=(:outdata,lam,false)
    end
            

    hash.push_to_module_stack(DataInf_C,:data_connect_pipe_inf)
    hash.open_error = true
    return hash
end
inst_data_inf_c_pipe_condition( and_condition:"and_condition", indata:"indata", outdata:"outdata") click to toggle source
# File lib/tdl/data_inf/bak/data_inf_c_pipe_condition_auto.rb, line 99
def Tdl.inst_data_inf_c_pipe_condition(
    and_condition:"and_condition",
    indata:"indata",
    outdata:"outdata")
    hash = TdlHash.new
    
    unless and_condition.is_a? Hash
        hash.case_record(:and_condition,and_condition)
    else
        # hash.new_index(:and_condition)= lambda { a = Logic.new(and_condition);a.name = "and_condition";return a }
        # hash[:and_condition] = lambda { a = Logic.new(and_condition);a.name = "and_condition";return a }
        raise TdlError.new('data_inf_c_pipe_condition Logic and_condition TdlHash cant include Proc') if and_condition.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(and_condition)
            unless and_condition[:name]
                a.name = "and_condition"
            end
            return a }
        hash.[]=(:and_condition,lam,false)
    end
            

    unless indata.is_a? Hash
        hash.case_record(:indata,indata)
    else
        # hash.new_index(:indata)= lambda { a = DataInf_C.new(indata);a.name = "indata";return a }
        # hash[:indata] = lambda { a = DataInf_C.new(indata);a.name = "indata";return a }
        raise TdlError.new('data_inf_c_pipe_condition DataInf_C indata TdlHash cant include Proc') if indata.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf_C.new(indata)
            unless indata[:name]
                a.name = "indata"
            end
            return a }
        hash.[]=(:indata,lam,false)
    end
            

    unless outdata.is_a? Hash
        hash.case_record(:outdata,outdata)
    else
        # hash.new_index(:outdata)= lambda { a = DataInf_C.new(outdata);a.name = "outdata";return a }
        # hash[:outdata] = lambda { a = DataInf_C.new(outdata);a.name = "outdata";return a }
        raise TdlError.new('data_inf_c_pipe_condition DataInf_C outdata TdlHash cant include Proc') if outdata.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf_C.new(outdata)
            unless outdata[:name]
                a.name = "outdata"
            end
            return a }
        hash.[]=(:outdata,lam,false)
    end
            

    hash.push_to_module_stack(DataInf_C,:data_inf_c_pipe_condition)
    hash.open_error = true
    return hash
end
inst_data_mirrors( h:0, l:0, mode:"CDS_MODE", condition_data:"condition_data", data_in:"data_in", data_mirror:"data_mirror") click to toggle source
# File lib/tdl/data_inf/bak/_data_mirrors.rb, line 118
def Tdl.inst_data_mirrors(
    h:0,
    l:0,
    mode:"CDS_MODE",
    condition_data:"condition_data",
    data_in:"data_in",
    data_mirror:"data_mirror")
    hash = TdlHash.new

    unless h.is_a? Hash
        # hash.new_index(:h) = h
        if h.is_a? BaseElm
            hash.[]=(:h,h,true)
        else
            hash.[]=(:h,h,false)
        end
    else
        # hash.new_index(:h)= lambda { a = Parameter.new(h);a.name = "h";return a }
        # hash[:h] = lambda { a = Parameter.new(h);a.name = "h";return a }
        lam = lambda {
            a = Parameter.new(h)
            unless h[:name]
                a.name = "h"
            end
            return a }
        hash.[]=(:h,lam,false)
    end


    unless l.is_a? Hash
        # hash.new_index(:l) = l
        if l.is_a? BaseElm
            hash.[]=(:l,l,true)
        else
            hash.[]=(:l,l,false)
        end
    else
        # hash.new_index(:l)= lambda { a = Parameter.new(l);a.name = "l";return a }
        # hash[:l] = lambda { a = Parameter.new(l);a.name = "l";return a }
        lam = lambda {
            a = Parameter.new(l)
            unless l[:name]
                a.name = "l"
            end
            return a }
        hash.[]=(:l,lam,false)
    end


    unless mode.is_a? Hash
        # hash.new_index(:mode) = mode
        if mode.is_a? BaseElm
            hash.[]=(:mode,mode,true)
        else
            hash.[]=(:mode,mode,false)
        end
    else
        # hash.new_index(:mode)= lambda { a = Parameter.new(mode);a.name = "mode";return a }
        # hash[:mode] = lambda { a = Parameter.new(mode);a.name = "mode";return a }
        lam = lambda {
            a = Parameter.new(mode)
            unless mode[:name]
                a.name = "mode"
            end
            return a }
        hash.[]=(:mode,lam,false)
    end


    unless condition_data.is_a? Hash
        # hash.new_index(:condition_data) = condition_data
        if condition_data.is_a? BaseElm
            hash.[]=(:condition_data,condition_data,true)
        else
            hash.[]=(:condition_data,condition_data,false)
        end
    else
        # hash.new_index(:condition_data)= lambda { a = Logic.new(condition_data);a.name = "condition_data";return a }
        # hash[:condition_data] = lambda { a = Logic.new(condition_data);a.name = "condition_data";return a }
        lam = lambda {
            a = Logic.new(condition_data)
            unless condition_data[:name]
                a.name = "condition_data"
            end
            return a }
        hash.[]=(:condition_data,lam,false)
    end


    unless data_in.is_a? Hash
        # hash.new_index(:data_in) = data_in
        if data_in.is_a? BaseElm
            hash.[]=(:data_in,data_in,true)
        else
            hash.[]=(:data_in,data_in,false)
        end
    else
        # hash.new_index(:data_in)= lambda { a = DataInf_C.new(data_in);a.name = "data_in";return a }
        # hash[:data_in] = lambda { a = DataInf_C.new(data_in);a.name = "data_in";return a }
        lam = lambda {
            a = DataInf_C.new(data_in)
            unless data_in[:name]
                a.name = "data_in"
            end
            return a }
        hash.[]=(:data_in,lam,false)
    end

    unless data_mirror.is_a? Hash
        # hash.new_index(:data_mirror) = data_mirror
        if data_mirror.is_a? BaseElm
            hash.[]=(:data_mirror,data_mirror,true)
        else
            hash.[]=(:data_mirror,data_mirror,false)
        end
    else
        # hash.new_index(:data_mirror)= lambda { a = DataInf_C.new(data_mirror);a.name = "data_mirror";return a }
        # hash[:data_mirror] = lambda { a = DataInf_C.new(data_mirror);a.name = "data_mirror";return a }
        lam = lambda {
            a = DataInf_C.new(data_mirror)
            unless data_mirror[:name]
                a.name = "data_mirror"
            end
            return a }
        hash.[]=(:data_mirror,lam,false)
    end

    # p data_mirror

    Tdl.module_stack  << lambda {
        hash.each do |k,v|
            if v.is_a? Proc
                hash.[]=(k,v.call,false)
            elsif v.is_a? Array
            #    unless v.empty?
            #        if v[0].is_a? Axi4
            #            cm = v[0].copy(name:k,idsize:Math.log2(v.length).ceil+v[0].idsize)
            #        else
            #            cm = v[0].copy(name:k)
            #        end
            #        cm.<<(*v)
            #        # hash[k] = cm
            #        hash.[]=(k,cm)
            #    else
            #        hash.[]=(k,nil,false)
            #    end
            else
                # hash[k] = v
            end
        end
        hash.check_use("data_mirrors")
        DataInf_C.data_mirrors(hash)
    }
    return hash
end
inst_data_mirrors_verb( h:0, l:0, num:8, mode:"CDS_MODE", condition_data:"condition_data", data_in:"data_in", data_mirror:"data_mirror") click to toggle source
# File lib/tdl/data_inf/bak/data_mirrors_verb.sv_auto.rb, line 108
def Tdl.inst_data_mirrors_verb(
    h:0,
    l:0,
    num:8,
    mode:"CDS_MODE",
    condition_data:"condition_data",
    data_in:"data_in",
    data_mirror:"data_mirror")
    hash = TdlHash.new
    
    unless h.is_a? Hash
        hash.case_record(:h,h)
    else
        # hash.new_index(:h)= lambda { a = Parameter.new(h);a.name = "h";return a }
        # hash[:h] = lambda { a = Parameter.new(h);a.name = "h";return a }
        raise TdlError.new('data_mirrors_verb Parameter h TdlHash cant include Proc') if h.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(h)
            unless h[:name]
                a.name = "h"
            end
            return a }
        hash.[]=(:h,lam,false)
    end
            

    unless l.is_a? Hash
        hash.case_record(:l,l)
    else
        # hash.new_index(:l)= lambda { a = Parameter.new(l);a.name = "l";return a }
        # hash[:l] = lambda { a = Parameter.new(l);a.name = "l";return a }
        raise TdlError.new('data_mirrors_verb Parameter l TdlHash cant include Proc') if l.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(l)
            unless l[:name]
                a.name = "l"
            end
            return a }
        hash.[]=(:l,lam,false)
    end
            

    unless num.is_a? Hash
        hash.case_record(:num,num)
    else
        # hash.new_index(:num)= lambda { a = Parameter.new(num);a.name = "num";return a }
        # hash[:num] = lambda { a = Parameter.new(num);a.name = "num";return a }
        raise TdlError.new('data_mirrors_verb Parameter num TdlHash cant include Proc') if num.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(num)
            unless num[:name]
                a.name = "num"
            end
            return a }
        hash.[]=(:num,lam,false)
    end
            

    unless mode.is_a? Hash
        hash.case_record(:mode,mode)
    else
        # hash.new_index(:mode)= lambda { a = Parameter.new(mode);a.name = "mode";return a }
        # hash[:mode] = lambda { a = Parameter.new(mode);a.name = "mode";return a }
        raise TdlError.new('data_mirrors_verb Parameter mode TdlHash cant include Proc') if mode.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(mode)
            unless mode[:name]
                a.name = "mode"
            end
            return a }
        hash.[]=(:mode,lam,false)
    end
            

    unless condition_data.is_a? Hash
        hash.case_record(:condition_data,condition_data)
    else
        # hash.new_index(:condition_data)= lambda { a = Logic.new(condition_data);a.name = "condition_data";return a }
        # hash[:condition_data] = lambda { a = Logic.new(condition_data);a.name = "condition_data";return a }
        raise TdlError.new('data_mirrors_verb Logic condition_data TdlHash cant include Proc') if condition_data.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(condition_data)
            unless condition_data[:name]
                a.name = "condition_data"
            end
            return a }
        hash.[]=(:condition_data,lam,false)
    end
            

    unless data_in.is_a? Hash
        hash.case_record(:data_in,data_in)
    else
        # hash.new_index(:data_in)= lambda { a = DataInf_C.new(data_in);a.name = "data_in";return a }
        # hash[:data_in] = lambda { a = DataInf_C.new(data_in);a.name = "data_in";return a }
        raise TdlError.new('data_mirrors_verb DataInf_C data_in TdlHash cant include Proc') if data_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf_C.new(data_in)
            unless data_in[:name]
                a.name = "data_in"
            end
            return a }
        hash.[]=(:data_in,lam,false)
    end
            

    unless data_mirror.is_a? Hash
        hash.case_record(:data_mirror,data_mirror)
    else
        # hash.new_index(:data_mirror)= lambda { a = DataInf_C.new(data_mirror);a.name = "data_mirror";return a }
        # hash[:data_mirror] = lambda { a = DataInf_C.new(data_mirror);a.name = "data_mirror";return a }
        raise TdlError.new('data_mirrors_verb DataInf_C data_mirror TdlHash cant include Proc') if data_mirror.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf_C.new(data_mirror)
            unless data_mirror[:name]
                a.name = "data_mirror"
            end
            return a }
        hash.[]=(:data_mirror,lam,false)
    end
            

    hash.push_to_module_stack(DataInf_C,:data_mirrors_verb)
    hash.open_error = true
    return hash
end
inst_data_to_axis_inf( mark_curr_data:"mark_curr_data", last_flag:"last_flag", data_slaver:"data_slaver", axis_master:"axis_master") click to toggle source
# File lib/tdl/axi_stream/bak/data_to_axis_inf_auto.rb, line 71
def Tdl.inst_data_to_axis_inf(
    mark_curr_data:"mark_curr_data",
    last_flag:"last_flag",
    data_slaver:"data_slaver",
    axis_master:"axis_master")
    hash = TdlHash.new
    
    unless mark_curr_data.is_a? Hash
        hash.case_record(:mark_curr_data,mark_curr_data)
    else
        # hash.new_index(:mark_curr_data)= lambda { a = Logic.new(mark_curr_data);a.name = "mark_curr_data";return a }
        # hash[:mark_curr_data] = lambda { a = Logic.new(mark_curr_data);a.name = "mark_curr_data";return a }
        raise TdlError.new('data_to_axis_inf Logic mark_curr_data TdlHash cant include Proc') if mark_curr_data.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(mark_curr_data)
            unless mark_curr_data[:name]
                a.name = "mark_curr_data"
            end
            return a }
        hash.[]=(:mark_curr_data,lam,false)
    end
            

    unless last_flag.is_a? Hash
        hash.case_record(:last_flag,last_flag)
    else
        # hash.new_index(:last_flag)= lambda { a = Logic.new(last_flag);a.name = "last_flag";return a }
        # hash[:last_flag] = lambda { a = Logic.new(last_flag);a.name = "last_flag";return a }
        raise TdlError.new('data_to_axis_inf Logic last_flag TdlHash cant include Proc') if last_flag.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(last_flag)
            unless last_flag[:name]
                a.name = "last_flag"
            end
            return a }
        hash.[]=(:last_flag,lam,false)
    end
            

    unless data_slaver.is_a? Hash
        hash.case_record(:data_slaver,data_slaver)
    else
        # hash.new_index(:data_slaver)= lambda { a = DataInf_C.new(data_slaver);a.name = "data_slaver";return a }
        # hash[:data_slaver] = lambda { a = DataInf_C.new(data_slaver);a.name = "data_slaver";return a }
        raise TdlError.new('data_to_axis_inf DataInf_C data_slaver TdlHash cant include Proc') if data_slaver.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf_C.new(data_slaver)
            unless data_slaver[:name]
                a.name = "data_slaver"
            end
            return a }
        hash.[]=(:data_slaver,lam,false)
    end
            

    unless axis_master.is_a? Hash
        hash.case_record(:axis_master,axis_master)
    else
        # hash.new_index(:axis_master)= lambda { a = AxiStream.new(axis_master);a.name = "axis_master";return a }
        # hash[:axis_master] = lambda { a = AxiStream.new(axis_master);a.name = "axis_master";return a }
        raise TdlError.new('data_to_axis_inf AxiStream axis_master TdlHash cant include Proc') if axis_master.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_master)
            unless axis_master[:name]
                a.name = "axis_master"
            end
            return a }
        hash.[]=(:axis_master,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:data_to_axis_inf)
    hash.open_error = true
    return hash
end
inst_data_to_axis_inf_a1(last_flag:"last_flag",data_slaver:"data_slaver",axis_master:"axis_master") click to toggle source
# File lib/tdl/axi_stream/bak/data_to_axis_inf_A1.rb, line 58
def self.inst_data_to_axis_inf_a1(last_flag:"last_flag",data_slaver:"data_slaver",axis_master:"axis_master")
    hash = TdlHash.new

    unless last_flag.is_a? Hash
        # hash.new_index(:last_flag) = last_flag
        if last_flag.is_a? InfElm
            hash.[]=(:last_flag,last_flag,true)
        else
            hash.[]=(:last_flag,last_flag,false)
        end
    else
        # hash.new_index(:last_flag)= lambda { a = Logic.new(last_flag);a.name = "last_flag";return a }
        # hash[:last_flag] = lambda { a = Logic.new(last_flag);a.name = "last_flag";return a }
        hash.[]=(:last_flag,lambda { a = Logic.new(last_flag);a.name = "last_flag";return a },false)
    end


    unless data_slaver.is_a? Hash
        # hash.new_index(:data_slaver) = data_slaver
        if data_slaver.is_a? InfElm
            hash.[]=(:data_slaver,data_slaver,true)
        else
            hash.[]=(:data_slaver,data_slaver,false)
        end
    else
        # hash.new_index(:data_slaver)= lambda { a = DataInf_C.new(data_slaver);a.name = "data_slaver";return a }
        # hash[:data_slaver] = lambda { a = DataInf_C.new(data_slaver);a.name = "data_slaver";return a }
        hash.[]=(:data_slaver,lambda { a = DataInf_C.new(data_slaver);a.name = "data_slaver";return a },false)
    end


    unless axis_master.is_a? Hash
        # hash.new_index(:axis_master) = axis_master
        if axis_master.is_a? InfElm
            hash.[]=(:axis_master,axis_master,true)
        else
            hash.[]=(:axis_master,axis_master,false)
        end
    else
        # hash.new_index(:axis_master)= lambda { a = AxiStream.new(axis_master);a.name = "axis_master";return a }
        # hash[:axis_master] = lambda { a = AxiStream.new(axis_master);a.name = "axis_master";return a }
        hash.[]=(:axis_master,lambda { a = AxiStream.new(axis_master);a.name = "axis_master";return a },false)
    end


    Tdl.module_stack  << lambda {
        hash.each do |k,v|
            if v.is_a? Proc
                hash.[]=(k,v.call,false)
            elsif v.is_a? Array
                unless v.empty?
                    if v[0].is_a? Axi4
                        cm = v[0].copy(name:k,idsize:Math.log2(v.length).ceil+v[0].idsize)
                    else
                        cm = v[0].copy(name:k)
                    end
                    cm.<<(*v)
                    # hash[k] = cm
                    hash.[]=(k,cm)
                else
                    hash.[]=(k,nil,false)
                end
            else
                # hash[k] = v
            end
        end
        hash.check_use("data_to_axis_inf_a1")
        AxiStream.data_to_axis_inf_a1(hash)
    }
    return hash
end
inst_data_uncompress( asize:8, lsize:8, data_zip:"data_zip", data_unzip:"data_unzip") click to toggle source
# File lib/tdl/data_inf/bak/data_uncompress_auto.rb, line 102
def Tdl.inst_data_uncompress(
    asize:8,
    lsize:8,
    data_zip:"data_zip",
    data_unzip:"data_unzip")
    hash = TdlHash.new
    
    unless asize.is_a? Hash
        hash.case_record(:asize,asize)
    else
        # hash.new_index(:asize)= lambda { a = Parameter.new(asize);a.name = "asize";return a }
        # hash[:asize] = lambda { a = Parameter.new(asize);a.name = "asize";return a }
        raise TdlError.new('data_uncompress Parameter asize TdlHash cant include Proc') if asize.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(asize)
            unless asize[:name]
                a.name = "asize"
            end
            return a }
        hash.[]=(:asize,lam,false)
    end
            

    unless lsize.is_a? Hash
        hash.case_record(:lsize,lsize)
    else
        # hash.new_index(:lsize)= lambda { a = Parameter.new(lsize);a.name = "lsize";return a }
        # hash[:lsize] = lambda { a = Parameter.new(lsize);a.name = "lsize";return a }
        raise TdlError.new('data_uncompress Parameter lsize TdlHash cant include Proc') if lsize.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(lsize)
            unless lsize[:name]
                a.name = "lsize"
            end
            return a }
        hash.[]=(:lsize,lam,false)
    end
            

    unless data_zip.is_a? Hash
        hash.case_record(:data_zip,data_zip)
    else
        # hash.new_index(:data_zip)= lambda { a = DataInf_C.new(data_zip);a.name = "data_zip";return a }
        # hash[:data_zip] = lambda { a = DataInf_C.new(data_zip);a.name = "data_zip";return a }
        raise TdlError.new('data_uncompress DataInf_C data_zip TdlHash cant include Proc') if data_zip.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf_C.new(data_zip)
            unless data_zip[:name]
                a.name = "data_zip"
            end
            return a }
        hash.[]=(:data_zip,lam,false)
    end
            

    unless data_unzip.is_a? Hash
        hash.case_record(:data_unzip,data_unzip)
    else
        # hash.new_index(:data_unzip)= lambda { a = DataInf_C.new(data_unzip);a.name = "data_unzip";return a }
        # hash[:data_unzip] = lambda { a = DataInf_C.new(data_unzip);a.name = "data_unzip";return a }
        raise TdlError.new('data_uncompress DataInf_C data_unzip TdlHash cant include Proc') if data_unzip.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf_C.new(data_unzip)
            unless data_unzip[:name]
                a.name = "data_unzip"
            end
            return a }
        hash.[]=(:data_unzip,lam,false)
    end
            

    hash.push_to_module_stack(DataInf_C,:data_uncompress)
    hash.open_error = true
    return hash
end
inst_data_valve( button:"button", data_in:"data_in", data_out:"data_out") click to toggle source
# File lib/tdl/data_inf/bak/data_valve_auto.rb, line 69
def Tdl.inst_data_valve(
    button:"button",
    data_in:"data_in",
    data_out:"data_out")
    hash = TdlHash.new
    
    unless button.is_a? Hash
        hash.case_record(:button,button)
    else
        # hash.new_index(:button)= lambda { a = Logic.new(button);a.name = "button";return a }
        # hash[:button] = lambda { a = Logic.new(button);a.name = "button";return a }
        raise TdlError.new('data_valve Logic button TdlHash cant include Proc') if button.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(button)
            unless button[:name]
                a.name = "button"
            end
            return a }
        hash.[]=(:button,lam,false)
    end
            

    unless data_in.is_a? Hash
        hash.case_record(:data_in,data_in)
    else
        # hash.new_index(:data_in)= lambda { a = DataInf_C.new(data_in);a.name = "data_in";return a }
        # hash[:data_in] = lambda { a = DataInf_C.new(data_in);a.name = "data_in";return a }
        raise TdlError.new('data_valve DataInf_C data_in TdlHash cant include Proc') if data_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf_C.new(data_in)
            unless data_in[:name]
                a.name = "data_in"
            end
            return a }
        hash.[]=(:data_in,lam,false)
    end
            

    unless data_out.is_a? Hash
        hash.case_record(:data_out,data_out)
    else
        # hash.new_index(:data_out)= lambda { a = DataInf_C.new(data_out);a.name = "data_out";return a }
        # hash[:data_out] = lambda { a = DataInf_C.new(data_out);a.name = "data_out";return a }
        raise TdlError.new('data_valve DataInf_C data_out TdlHash cant include Proc') if data_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf_C.new(data_out)
            unless data_out[:name]
                a.name = "data_out"
            end
            return a }
        hash.[]=(:data_out,lam,false)
    end
            

    hash.push_to_module_stack(DataInf_C,:data_valve)
    hash.open_error = true
    return hash
end
inst_datainf_c_master_empty(master:"master") click to toggle source
# File lib/tdl/axi_stream/bak/datainf_c_master_empty_auto.rb, line 66
def Tdl.inst_datainf_c_master_empty(master:"master")
    hash = TdlHash.new
    
    unless master.is_a? Hash
        # hash.new_index(:master) = master
        if master.is_a? BaseElm
            hash.[]=(:master,master,true)
        else
            hash.[]=(:master,master,false)
        end
    else
        # hash.new_index(:master)= lambda { a = DataInf_C.new(master);a.name = "master";return a }
        # hash[:master] = lambda { a = DataInf_C.new(master);a.name = "master";return a }
        lam = lambda {
            a = DataInf_C.new(master)
            unless master[:name]
                a.name = "master"
            end
            return a }
        hash.[]=(:master,lam,false)
    end
            

    Tdl.module_stack  << lambda {
        hash.each do |k,v|
            if v.is_a? Proc
                hash.[]=(k,v.call,false)
            elsif v.is_a? Array
                unless v.empty?
                    if v[0].is_a? Axi4
                        cm = v[0].copy(name:k,idsize:Math.log2(v.length).ceil+v[0].idsize)
                    else
                        cm = v[0].copy(name:k)
                    end
                    cm.<<(*v)
                    # hash[k] = cm
                    hash.[]=(k,cm)
                else
                    hash.[]=(k,nil,false)
                end
            else
                # hash[k] = v
            end
        end
        hash.check_use("datainf_c_master_empty")
        DataInf_C.datainf_c_master_empty(hash)
    }
    return hash
end
inst_datainf_c_slaver_empty(slaver:"slaver") click to toggle source
# File lib/tdl/axi_stream/bak/datainf_c_slaver_empty_auto.rb, line 59
def Tdl.inst_datainf_c_slaver_empty(slaver:"slaver")
    hash = TdlHash.new
    
    unless slaver.is_a? Hash
        # hash.new_index(:slaver) = slaver
        if slaver.is_a? BaseElm
            hash.[]=(:slaver,slaver,true)
        else
            hash.[]=(:slaver,slaver,false)
        end
    else
        # hash.new_index(:slaver)= lambda { a = DataInf_C.new(slaver);a.name = "slaver";return a }
        # hash[:slaver] = lambda { a = DataInf_C.new(slaver);a.name = "slaver";return a }
        lam = lambda {
            a = DataInf_C.new(slaver)
            unless slaver[:name]
                a.name = "slaver"
            end
            return a }
        hash.[]=(:slaver,lam,false)
    end
            

    Tdl.module_stack  << lambda {
        hash.each do |k,v|
            if v.is_a? Proc
                hash.[]=(k,v.call,false)
            elsif v.is_a? Array
                unless v.empty?
                    if v[0].is_a? Axi4
                        cm = v[0].copy(name:k,idsize:Math.log2(v.length).ceil+v[0].idsize)
                    else
                        cm = v[0].copy(name:k)
                    end
                    cm.<<(*v)
                    # hash[k] = cm
                    hash.[]=(k,cm)
                else
                    hash.[]=(k,nil,false)
                end
            else
                # hash[k] = v
            end
        end
        hash.check_use("datainf_c_slaver_empty")
        DataInf_C.datainf_c_slaver_empty(hash)
    }
    return hash
end
inst_datainf_master_empty(master:"master") click to toggle source
# File lib/tdl/axi_stream/bak/datainf_master_empty_auto.rb, line 66
def Tdl.inst_datainf_master_empty(master:"master")
    hash = TdlHash.new
    
    unless master.is_a? Hash
        # hash.new_index(:master) = master
        if master.is_a? BaseElm
            hash.[]=(:master,master,true)
        else
            hash.[]=(:master,master,false)
        end
    else
        # hash.new_index(:master)= lambda { a = DataInf.new(master);a.name = "master";return a }
        # hash[:master] = lambda { a = DataInf.new(master);a.name = "master";return a }
        lam = lambda {
            a = DataInf.new(master)
            unless master[:name]
                a.name = "master"
            end
            return a }
        hash.[]=(:master,lam,false)
    end
            

    Tdl.module_stack  << lambda {
        hash.each do |k,v|
            if v.is_a? Proc
                hash.[]=(k,v.call,false)
            elsif v.is_a? Array
                unless v.empty?
                    if v[0].is_a? Axi4
                        cm = v[0].copy(name:k,idsize:Math.log2(v.length).ceil+v[0].idsize)
                    else
                        cm = v[0].copy(name:k)
                    end
                    cm.<<(*v)
                    # hash[k] = cm
                    hash.[]=(k,cm)
                else
                    hash.[]=(k,nil,false)
                end
            else
                # hash[k] = v
            end
        end
        hash.check_use("datainf_master_empty")
        DataInf.datainf_master_empty(hash)
    }
    return hash
end
inst_datainf_slaver_empty(slaver:"slaver") click to toggle source
# File lib/tdl/axi_stream/bak/datainf_slaver_empty_auto.rb, line 59
def Tdl.inst_datainf_slaver_empty(slaver:"slaver")
    hash = TdlHash.new
    
    unless slaver.is_a? Hash
        # hash.new_index(:slaver) = slaver
        if slaver.is_a? BaseElm
            hash.[]=(:slaver,slaver,true)
        else
            hash.[]=(:slaver,slaver,false)
        end
    else
        # hash.new_index(:slaver)= lambda { a = DataInf.new(slaver);a.name = "slaver";return a }
        # hash[:slaver] = lambda { a = DataInf.new(slaver);a.name = "slaver";return a }
        lam = lambda {
            a = DataInf.new(slaver)
            unless slaver[:name]
                a.name = "slaver"
            end
            return a }
        hash.[]=(:slaver,lam,false)
    end
            

    Tdl.module_stack  << lambda {
        hash.each do |k,v|
            if v.is_a? Proc
                hash.[]=(k,v.call,false)
            elsif v.is_a? Array
                unless v.empty?
                    if v[0].is_a? Axi4
                        cm = v[0].copy(name:k,idsize:Math.log2(v.length).ceil+v[0].idsize)
                    else
                        cm = v[0].copy(name:k)
                    end
                    cm.<<(*v)
                    # hash[k] = cm
                    hash.[]=(k,cm)
                else
                    hash.[]=(k,nil,false)
                end
            else
                # hash[k] = v
            end
        end
        hash.check_use("datainf_slaver_empty")
        DataInf.datainf_slaver_empty(hash)
    }
    return hash
end
inst_dynamic_port_cfg(udp_port:"udp_port", port_index:"port_index", valid:"valid", tap_ex_udp_ctrl_inf:"tap_ex_udp_ctrl_inf", tap_local_udp_ctrl_inf:"tap_local_udp_ctrl_inf", tap_broadcast_udp_inf:"tap_broadcast_udp_inf", send_inf:"send_inf") click to toggle source
# File lib/tdl/axi_stream/bak/dynamic_port_cfg_auto.rb, line 71
def Tdl.inst_dynamic_port_cfg(udp_port:"udp_port",
    port_index:"port_index",
    valid:"valid",
    tap_ex_udp_ctrl_inf:"tap_ex_udp_ctrl_inf",
    tap_local_udp_ctrl_inf:"tap_local_udp_ctrl_inf",
    tap_broadcast_udp_inf:"tap_broadcast_udp_inf",
    send_inf:"send_inf")
    hash = TdlHash.new
    
    unless udp_port.is_a? Hash
        # hash.new_index(:udp_port) = udp_port
        if udp_port.is_a? BaseElm
            hash.[]=(:udp_port,udp_port,true)
        else
            hash.[]=(:udp_port,udp_port,false)
        end
    else
        # hash.new_index(:udp_port)= lambda { a = Logic.new(udp_port);a.name = "udp_port";return a }
        # hash[:udp_port] = lambda { a = Logic.new(udp_port);a.name = "udp_port";return a }
        lam = lambda {
            a = Logic.new(udp_port)
            unless udp_port[:name]
                a.name = "udp_port"
            end
            return a }
        hash.[]=(:udp_port,lam,false)
    end
            

    unless port_index.is_a? Hash
        # hash.new_index(:port_index) = port_index
        if port_index.is_a? BaseElm
            hash.[]=(:port_index,port_index,true)
        else
            hash.[]=(:port_index,port_index,false)
        end
    else
        # hash.new_index(:port_index)= lambda { a = Logic.new(port_index);a.name = "port_index";return a }
        # hash[:port_index] = lambda { a = Logic.new(port_index);a.name = "port_index";return a }
        lam = lambda {
            a = Logic.new(port_index)
            unless port_index[:name]
                a.name = "port_index"
            end
            return a }
        hash.[]=(:port_index,lam,false)
    end
            

    unless valid.is_a? Hash
        # hash.new_index(:valid) = valid
        if valid.is_a? BaseElm
            hash.[]=(:valid,valid,true)
        else
            hash.[]=(:valid,valid,false)
        end
    else
        # hash.new_index(:valid)= lambda { a = Logic.new(valid);a.name = "valid";return a }
        # hash[:valid] = lambda { a = Logic.new(valid);a.name = "valid";return a }
        lam = lambda {
            a = Logic.new(valid)
            unless valid[:name]
                a.name = "valid"
            end
            return a }
        hash.[]=(:valid,lam,false)
    end
            

    unless tap_ex_udp_ctrl_inf.is_a? Hash
        # hash.new_index(:tap_ex_udp_ctrl_inf) = tap_ex_udp_ctrl_inf
        if tap_ex_udp_ctrl_inf.is_a? BaseElm
            hash.[]=(:tap_ex_udp_ctrl_inf,tap_ex_udp_ctrl_inf,true)
        else
            hash.[]=(:tap_ex_udp_ctrl_inf,tap_ex_udp_ctrl_inf,false)
        end
    else
        # hash.new_index(:tap_ex_udp_ctrl_inf)= lambda { a = AxiStream.new(tap_ex_udp_ctrl_inf);a.name = "tap_ex_udp_ctrl_inf";return a }
        # hash[:tap_ex_udp_ctrl_inf] = lambda { a = AxiStream.new(tap_ex_udp_ctrl_inf);a.name = "tap_ex_udp_ctrl_inf";return a }
        lam = lambda {
            a = AxiStream.new(tap_ex_udp_ctrl_inf)
            unless tap_ex_udp_ctrl_inf[:name]
                a.name = "tap_ex_udp_ctrl_inf"
            end
            return a }
        hash.[]=(:tap_ex_udp_ctrl_inf,lam,false)
    end
            

    unless tap_local_udp_ctrl_inf.is_a? Hash
        # hash.new_index(:tap_local_udp_ctrl_inf) = tap_local_udp_ctrl_inf
        if tap_local_udp_ctrl_inf.is_a? BaseElm
            hash.[]=(:tap_local_udp_ctrl_inf,tap_local_udp_ctrl_inf,true)
        else
            hash.[]=(:tap_local_udp_ctrl_inf,tap_local_udp_ctrl_inf,false)
        end
    else
        # hash.new_index(:tap_local_udp_ctrl_inf)= lambda { a = AxiStream.new(tap_local_udp_ctrl_inf);a.name = "tap_local_udp_ctrl_inf";return a }
        # hash[:tap_local_udp_ctrl_inf] = lambda { a = AxiStream.new(tap_local_udp_ctrl_inf);a.name = "tap_local_udp_ctrl_inf";return a }
        lam = lambda {
            a = AxiStream.new(tap_local_udp_ctrl_inf)
            unless tap_local_udp_ctrl_inf[:name]
                a.name = "tap_local_udp_ctrl_inf"
            end
            return a }
        hash.[]=(:tap_local_udp_ctrl_inf,lam,false)
    end
            

    unless tap_broadcast_udp_inf.is_a? Hash
        # hash.new_index(:tap_broadcast_udp_inf) = tap_broadcast_udp_inf
        if tap_broadcast_udp_inf.is_a? BaseElm
            hash.[]=(:tap_broadcast_udp_inf,tap_broadcast_udp_inf,true)
        else
            hash.[]=(:tap_broadcast_udp_inf,tap_broadcast_udp_inf,false)
        end
    else
        # hash.new_index(:tap_broadcast_udp_inf)= lambda { a = AxiStream.new(tap_broadcast_udp_inf);a.name = "tap_broadcast_udp_inf";return a }
        # hash[:tap_broadcast_udp_inf] = lambda { a = AxiStream.new(tap_broadcast_udp_inf);a.name = "tap_broadcast_udp_inf";return a }
        lam = lambda {
            a = AxiStream.new(tap_broadcast_udp_inf)
            unless tap_broadcast_udp_inf[:name]
                a.name = "tap_broadcast_udp_inf"
            end
            return a }
        hash.[]=(:tap_broadcast_udp_inf,lam,false)
    end
            

    unless send_inf.is_a? Hash
        # hash.new_index(:send_inf) = send_inf
        if send_inf.is_a? BaseElm
            hash.[]=(:send_inf,send_inf,true)
        else
            hash.[]=(:send_inf,send_inf,false)
        end
    else
        # hash.new_index(:send_inf)= lambda { a = AxiStream.new(send_inf);a.name = "send_inf";return a }
        # hash[:send_inf] = lambda { a = AxiStream.new(send_inf);a.name = "send_inf";return a }
        lam = lambda {
            a = AxiStream.new(send_inf)
            unless send_inf[:name]
                a.name = "send_inf"
            end
            return a }
        hash.[]=(:send_inf,lam,false)
    end
            

    Tdl.module_stack  << lambda {
        hash.each do |k,v|
            if v.is_a? Proc
                hash.[]=(k,v.call,false)
            elsif v.is_a? Array
                unless v.empty?
                    if v[0].is_a? Axi4
                        cm = v[0].copy(name:k,idsize:Math.log2(v.length).ceil+v[0].idsize)
                    else
                        cm = v[0].copy(name:k)
                    end
                    cm.<<(*v)
                    # hash[k] = cm
                    hash.[]=(k,cm)
                else
                    hash.[]=(k,nil,false)
                end
            else
                # hash[k] = v
            end
        end
        hash.check_use("dynamic_port_cfg")
        AxiStream.dynamic_port_cfg(hash)
    }
    return hash
end
inst_dynnamic_addr_cfg(server_ip:"server_ip", server_mac:"server_mac", tap_local_udp_ctrl_inf:"tap_local_udp_ctrl_inf", tap_broadcast_udp_inf:"tap_broadcast_udp_inf", send_inf:"send_inf") click to toggle source
# File lib/tdl/axi_stream/bak/dynnamic_addr_cfg_auto.rb, line 67
def Tdl.inst_dynnamic_addr_cfg(server_ip:"server_ip",
    server_mac:"server_mac",
    tap_local_udp_ctrl_inf:"tap_local_udp_ctrl_inf",
    tap_broadcast_udp_inf:"tap_broadcast_udp_inf",
    send_inf:"send_inf")
    hash = TdlHash.new
    
    unless server_ip.is_a? Hash
        # hash.new_index(:server_ip) = server_ip
        if server_ip.is_a? BaseElm
            hash.[]=(:server_ip,server_ip,true)
        else
            hash.[]=(:server_ip,server_ip,false)
        end
    else
        # hash.new_index(:server_ip)= lambda { a = Logic.new(server_ip);a.name = "server_ip";return a }
        # hash[:server_ip] = lambda { a = Logic.new(server_ip);a.name = "server_ip";return a }
        lam = lambda {
            a = Logic.new(server_ip)
            unless server_ip[:name]
                a.name = "server_ip"
            end
            return a }
        hash.[]=(:server_ip,lam,false)
    end
            

    unless server_mac.is_a? Hash
        # hash.new_index(:server_mac) = server_mac
        if server_mac.is_a? BaseElm
            hash.[]=(:server_mac,server_mac,true)
        else
            hash.[]=(:server_mac,server_mac,false)
        end
    else
        # hash.new_index(:server_mac)= lambda { a = Logic.new(server_mac);a.name = "server_mac";return a }
        # hash[:server_mac] = lambda { a = Logic.new(server_mac);a.name = "server_mac";return a }
        lam = lambda {
            a = Logic.new(server_mac)
            unless server_mac[:name]
                a.name = "server_mac"
            end
            return a }
        hash.[]=(:server_mac,lam,false)
    end
            

    unless tap_local_udp_ctrl_inf.is_a? Hash
        # hash.new_index(:tap_local_udp_ctrl_inf) = tap_local_udp_ctrl_inf
        if tap_local_udp_ctrl_inf.is_a? BaseElm
            hash.[]=(:tap_local_udp_ctrl_inf,tap_local_udp_ctrl_inf,true)
        else
            hash.[]=(:tap_local_udp_ctrl_inf,tap_local_udp_ctrl_inf,false)
        end
    else
        # hash.new_index(:tap_local_udp_ctrl_inf)= lambda { a = AxiStream.new(tap_local_udp_ctrl_inf);a.name = "tap_local_udp_ctrl_inf";return a }
        # hash[:tap_local_udp_ctrl_inf] = lambda { a = AxiStream.new(tap_local_udp_ctrl_inf);a.name = "tap_local_udp_ctrl_inf";return a }
        lam = lambda {
            a = AxiStream.new(tap_local_udp_ctrl_inf)
            unless tap_local_udp_ctrl_inf[:name]
                a.name = "tap_local_udp_ctrl_inf"
            end
            return a }
        hash.[]=(:tap_local_udp_ctrl_inf,lam,false)
    end
            

    unless tap_broadcast_udp_inf.is_a? Hash
        # hash.new_index(:tap_broadcast_udp_inf) = tap_broadcast_udp_inf
        if tap_broadcast_udp_inf.is_a? BaseElm
            hash.[]=(:tap_broadcast_udp_inf,tap_broadcast_udp_inf,true)
        else
            hash.[]=(:tap_broadcast_udp_inf,tap_broadcast_udp_inf,false)
        end
    else
        # hash.new_index(:tap_broadcast_udp_inf)= lambda { a = AxiStream.new(tap_broadcast_udp_inf);a.name = "tap_broadcast_udp_inf";return a }
        # hash[:tap_broadcast_udp_inf] = lambda { a = AxiStream.new(tap_broadcast_udp_inf);a.name = "tap_broadcast_udp_inf";return a }
        lam = lambda {
            a = AxiStream.new(tap_broadcast_udp_inf)
            unless tap_broadcast_udp_inf[:name]
                a.name = "tap_broadcast_udp_inf"
            end
            return a }
        hash.[]=(:tap_broadcast_udp_inf,lam,false)
    end
            

    unless send_inf.is_a? Hash
        # hash.new_index(:send_inf) = send_inf
        if send_inf.is_a? BaseElm
            hash.[]=(:send_inf,send_inf,true)
        else
            hash.[]=(:send_inf,send_inf,false)
        end
    else
        # hash.new_index(:send_inf)= lambda { a = AxiStream.new(send_inf);a.name = "send_inf";return a }
        # hash[:send_inf] = lambda { a = AxiStream.new(send_inf);a.name = "send_inf";return a }
        lam = lambda {
            a = AxiStream.new(send_inf)
            unless send_inf[:name]
                a.name = "send_inf"
            end
            return a }
        hash.[]=(:send_inf,lam,false)
    end
            

    Tdl.module_stack  << lambda {
        hash.each do |k,v|
            if v.is_a? Proc
                hash.[]=(k,v.call,false)
            elsif v.is_a? Array
                unless v.empty?
                    if v[0].is_a? Axi4
                        cm = v[0].copy(name:k,idsize:Math.log2(v.length).ceil+v[0].idsize)
                    else
                        cm = v[0].copy(name:k)
                    end
                    cm.<<(*v)
                    # hash[k] = cm
                    hash.[]=(k,cm)
                else
                    hash.[]=(k,nil,false)
                end
            else
                # hash[k] = v
            end
        end
        hash.check_use("dynnamic_addr_cfg")
        AxiStream.dynnamic_addr_cfg(hash)
    }
    return hash
end
inst_gen_big_field_table( master_mode:"OFF", dsize:8, field_len:16*8, field_name:"Big Filed", enable:"enable", value:"value", cm_tb:"cm_tb") click to toggle source
# File lib/tdl/axi_stream/bak/gen_big_field_table_auto.rb, line 84
def Tdl.inst_gen_big_field_table(
    master_mode:"OFF",
    dsize:8,
    field_len:16*8,
    field_name:"Big Filed",
    enable:"enable",
    value:"value",
    cm_tb:"cm_tb")
    hash = TdlHash.new
    
    unless master_mode.is_a? Hash
        hash.case_record(:master_mode,master_mode)
    else
        # hash.new_index(:master_mode)= lambda { a = Parameter.new(master_mode);a.name = "master_mode";return a }
        # hash[:master_mode] = lambda { a = Parameter.new(master_mode);a.name = "master_mode";return a }
        raise TdlError.new('gen_big_field_table Parameter master_mode TdlHash cant include Proc') if master_mode.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(master_mode)
            unless master_mode[:name]
                a.name = "master_mode"
            end
            return a }
        hash.[]=(:master_mode,lam,false)
    end
            

    unless dsize.is_a? Hash
        hash.case_record(:dsize,dsize)
    else
        # hash.new_index(:dsize)= lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        # hash[:dsize] = lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        raise TdlError.new('gen_big_field_table Parameter dsize TdlHash cant include Proc') if dsize.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(dsize)
            unless dsize[:name]
                a.name = "dsize"
            end
            return a }
        hash.[]=(:dsize,lam,false)
    end
            

    unless field_len.is_a? Hash
        hash.case_record(:field_len,field_len)
    else
        # hash.new_index(:field_len)= lambda { a = Parameter.new(field_len);a.name = "field_len";return a }
        # hash[:field_len] = lambda { a = Parameter.new(field_len);a.name = "field_len";return a }
        raise TdlError.new('gen_big_field_table Parameter field_len TdlHash cant include Proc') if field_len.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(field_len)
            unless field_len[:name]
                a.name = "field_len"
            end
            return a }
        hash.[]=(:field_len,lam,false)
    end
            

    unless field_name.is_a? Hash
        hash.case_record(:field_name,field_name)
    else
        # hash.new_index(:field_name)= lambda { a = Parameter.new(field_name);a.name = "field_name";return a }
        # hash[:field_name] = lambda { a = Parameter.new(field_name);a.name = "field_name";return a }
        raise TdlError.new('gen_big_field_table Parameter field_name TdlHash cant include Proc') if field_name.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(field_name)
            unless field_name[:name]
                a.name = "field_name"
            end
            return a }
        hash.[]=(:field_name,lam,false)
    end
            

    unless enable.is_a? Hash
        hash.case_record(:enable,enable)
    else
        # hash.new_index(:enable)= lambda { a = Logic.new(enable);a.name = "enable";return a }
        # hash[:enable] = lambda { a = Logic.new(enable);a.name = "enable";return a }
        raise TdlError.new('gen_big_field_table Logic enable TdlHash cant include Proc') if enable.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(enable)
            unless enable[:name]
                a.name = "enable"
            end
            return a }
        hash.[]=(:enable,lam,false)
    end
            

    unless value.is_a? Hash
        hash.case_record(:value,value)
    else
        # hash.new_index(:value)= lambda { a = Logic.new(value);a.name = "value";return a }
        # hash[:value] = lambda { a = Logic.new(value);a.name = "value";return a }
        raise TdlError.new('gen_big_field_table Logic value TdlHash cant include Proc') if value.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(value)
            unless value[:name]
                a.name = "value"
            end
            return a }
        hash.[]=(:value,lam,false)
    end
            

    unless cm_tb.is_a? Hash
        hash.case_record(:cm_tb,cm_tb)
    else
        # hash.new_index(:cm_tb)= lambda { a = AxiStream.new(cm_tb);a.name = "cm_tb";return a }
        # hash[:cm_tb] = lambda { a = AxiStream.new(cm_tb);a.name = "cm_tb";return a }
        raise TdlError.new('gen_big_field_table AxiStream cm_tb TdlHash cant include Proc') if cm_tb.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(cm_tb)
            unless cm_tb[:name]
                a.name = "cm_tb"
            end
            return a }
        hash.[]=(:cm_tb,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:gen_big_field_table)
    hash.open_error = true
    return hash
end
inst_gen_origin_axis( mode:"RANGE", enable:"enable", ready:"ready", length:"length", axis_out:"axis_out") click to toggle source
# File lib/tdl/axi_stream/bak/gen_origin_axis_auto.rb, line 80
def Tdl.inst_gen_origin_axis(
    mode:"RANGE",
    enable:"enable",
    ready:"ready",
    length:"length",
    axis_out:"axis_out")
    hash = TdlHash.new
    
    unless mode.is_a? Hash
        hash.case_record(:mode,mode)
    else
        # hash.new_index(:mode)= lambda { a = Parameter.new(mode);a.name = "mode";return a }
        # hash[:mode] = lambda { a = Parameter.new(mode);a.name = "mode";return a }
        raise TdlError.new('gen_origin_axis Parameter mode TdlHash cant include Proc') if mode.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(mode)
            unless mode[:name]
                a.name = "mode"
            end
            return a }
        hash.[]=(:mode,lam,false)
    end
            

    unless enable.is_a? Hash
        hash.case_record(:enable,enable)
    else
        # hash.new_index(:enable)= lambda { a = Logic.new(enable);a.name = "enable";return a }
        # hash[:enable] = lambda { a = Logic.new(enable);a.name = "enable";return a }
        raise TdlError.new('gen_origin_axis Logic enable TdlHash cant include Proc') if enable.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(enable)
            unless enable[:name]
                a.name = "enable"
            end
            return a }
        hash.[]=(:enable,lam,false)
    end
            

    unless ready.is_a? Hash
        hash.case_record(:ready,ready)
    else
        # hash.new_index(:ready)= lambda { a = Logic.new(ready);a.name = "ready";return a }
        # hash[:ready] = lambda { a = Logic.new(ready);a.name = "ready";return a }
        raise TdlError.new('gen_origin_axis Logic ready TdlHash cant include Proc') if ready.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(ready)
            unless ready[:name]
                a.name = "ready"
            end
            return a }
        hash.[]=(:ready,lam,false)
    end
            

    unless length.is_a? Hash
        hash.case_record(:length,length)
    else
        # hash.new_index(:length)= lambda { a = Logic.new(length);a.name = "length";return a }
        # hash[:length] = lambda { a = Logic.new(length);a.name = "length";return a }
        raise TdlError.new('gen_origin_axis Logic length TdlHash cant include Proc') if length.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(length)
            unless length[:name]
                a.name = "length"
            end
            return a }
        hash.[]=(:length,lam,false)
    end
            

    unless axis_out.is_a? Hash
        hash.case_record(:axis_out,axis_out)
    else
        # hash.new_index(:axis_out)= lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        # hash[:axis_out] = lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        raise TdlError.new('gen_origin_axis AxiStream axis_out TdlHash cant include Proc') if axis_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_out)
            unless axis_out[:name]
                a.name = "axis_out"
            end
            return a }
        hash.[]=(:axis_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:gen_origin_axis)
    hash.open_error = true
    return hash
end
inst_gen_simple_axis( mode:"RANGE", trigger:"trigger", gen_en:"gen_en", length:"length", led:"led", axis_out:"axis_out") click to toggle source
# File lib/tdl/axi_stream/bak/gen_simple_axis_auto.rb, line 82
def Tdl.inst_gen_simple_axis(
    mode:"RANGE",
    trigger:"trigger",
    gen_en:"gen_en",
    length:"length",
    led:"led",
    axis_out:"axis_out")
    hash = TdlHash.new
    
    unless mode.is_a? Hash
        hash.case_record(:mode,mode)
    else
        # hash.new_index(:mode)= lambda { a = Parameter.new(mode);a.name = "mode";return a }
        # hash[:mode] = lambda { a = Parameter.new(mode);a.name = "mode";return a }
        raise TdlError.new('gen_simple_axis Parameter mode TdlHash cant include Proc') if mode.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(mode)
            unless mode[:name]
                a.name = "mode"
            end
            return a }
        hash.[]=(:mode,lam,false)
    end
            

    unless trigger.is_a? Hash
        hash.case_record(:trigger,trigger)
    else
        # hash.new_index(:trigger)= lambda { a = Logic.new(trigger);a.name = "trigger";return a }
        # hash[:trigger] = lambda { a = Logic.new(trigger);a.name = "trigger";return a }
        raise TdlError.new('gen_simple_axis Logic trigger TdlHash cant include Proc') if trigger.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(trigger)
            unless trigger[:name]
                a.name = "trigger"
            end
            return a }
        hash.[]=(:trigger,lam,false)
    end
            

    unless gen_en.is_a? Hash
        hash.case_record(:gen_en,gen_en)
    else
        # hash.new_index(:gen_en)= lambda { a = Logic.new(gen_en);a.name = "gen_en";return a }
        # hash[:gen_en] = lambda { a = Logic.new(gen_en);a.name = "gen_en";return a }
        raise TdlError.new('gen_simple_axis Logic gen_en TdlHash cant include Proc') if gen_en.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(gen_en)
            unless gen_en[:name]
                a.name = "gen_en"
            end
            return a }
        hash.[]=(:gen_en,lam,false)
    end
            

    unless length.is_a? Hash
        hash.case_record(:length,length)
    else
        # hash.new_index(:length)= lambda { a = Logic.new(length);a.name = "length";return a }
        # hash[:length] = lambda { a = Logic.new(length);a.name = "length";return a }
        raise TdlError.new('gen_simple_axis Logic length TdlHash cant include Proc') if length.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(length)
            unless length[:name]
                a.name = "length"
            end
            return a }
        hash.[]=(:length,lam,false)
    end
            

    unless led.is_a? Hash
        hash.case_record(:led,led)
    else
        # hash.new_index(:led)= lambda { a = Logic.new(led);a.name = "led";return a }
        # hash[:led] = lambda { a = Logic.new(led);a.name = "led";return a }
        raise TdlError.new('gen_simple_axis Logic led TdlHash cant include Proc') if led.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(led)
            unless led[:name]
                a.name = "led"
            end
            return a }
        hash.[]=(:led,lam,false)
    end
            

    unless axis_out.is_a? Hash
        hash.case_record(:axis_out,axis_out)
    else
        # hash.new_index(:axis_out)= lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        # hash[:axis_out] = lambda { a = AxiStream.new(axis_out);a.name = "axis_out";return a }
        raise TdlError.new('gen_simple_axis AxiStream axis_out TdlHash cant include Proc') if axis_out.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_out)
            unless axis_out[:name]
                a.name = "axis_out"
            end
            return a }
        hash.[]=(:axis_out,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:gen_simple_axis)
    hash.open_error = true
    return hash
end
inst_idata_pool_axi4( dsize:8, source_addr:"source_addr", size:"size", valid:"valid", ready:"ready", last_drop:"last_drop", data:"data", empty:"empty", wr_en:"wr_en", sewage_valve:"sewage_valve", axi_master:"axi_master") click to toggle source
# File lib/tdl/axi4/bak/idata_pool_axi4_auto.rb, line 202
def Tdl.inst_idata_pool_axi4(
    dsize:8,
    source_addr:"source_addr",
    size:"size",
    valid:"valid",
    ready:"ready",
    last_drop:"last_drop",
    data:"data",
    empty:"empty",
    wr_en:"wr_en",
    sewage_valve:"sewage_valve",
    axi_master:"axi_master")
    hash = TdlHash.new
    
    unless dsize.is_a? Hash
        hash.case_record(:dsize,dsize)
    else
        # hash.new_index(:dsize)= lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        # hash[:dsize] = lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        raise TdlError.new('idata_pool_axi4 Parameter dsize TdlHash cant include Proc') if dsize.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(dsize)
            unless dsize[:name]
                a.name = "dsize"
            end
            return a }
        hash.[]=(:dsize,lam,false)
    end
            

    unless source_addr.is_a? Hash
        hash.case_record(:source_addr,source_addr)
    else
        # hash.new_index(:source_addr)= lambda { a = Logic.new(source_addr);a.name = "source_addr";return a }
        # hash[:source_addr] = lambda { a = Logic.new(source_addr);a.name = "source_addr";return a }
        raise TdlError.new('idata_pool_axi4 Logic source_addr TdlHash cant include Proc') if source_addr.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(source_addr)
            unless source_addr[:name]
                a.name = "source_addr"
            end
            return a }
        hash.[]=(:source_addr,lam,false)
    end
            

    unless size.is_a? Hash
        hash.case_record(:size,size)
    else
        # hash.new_index(:size)= lambda { a = Logic.new(size);a.name = "size";return a }
        # hash[:size] = lambda { a = Logic.new(size);a.name = "size";return a }
        raise TdlError.new('idata_pool_axi4 Logic size TdlHash cant include Proc') if size.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(size)
            unless size[:name]
                a.name = "size"
            end
            return a }
        hash.[]=(:size,lam,false)
    end
            

    unless valid.is_a? Hash
        hash.case_record(:valid,valid)
    else
        # hash.new_index(:valid)= lambda { a = Logic.new(valid);a.name = "valid";return a }
        # hash[:valid] = lambda { a = Logic.new(valid);a.name = "valid";return a }
        raise TdlError.new('idata_pool_axi4 Logic valid TdlHash cant include Proc') if valid.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(valid)
            unless valid[:name]
                a.name = "valid"
            end
            return a }
        hash.[]=(:valid,lam,false)
    end
            

    unless ready.is_a? Hash
        hash.case_record(:ready,ready)
    else
        # hash.new_index(:ready)= lambda { a = Logic.new(ready);a.name = "ready";return a }
        # hash[:ready] = lambda { a = Logic.new(ready);a.name = "ready";return a }
        raise TdlError.new('idata_pool_axi4 Logic ready TdlHash cant include Proc') if ready.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(ready)
            unless ready[:name]
                a.name = "ready"
            end
            return a }
        hash.[]=(:ready,lam,false)
    end
            

    unless last_drop.is_a? Hash
        hash.case_record(:last_drop,last_drop)
    else
        # hash.new_index(:last_drop)= lambda { a = Logic.new(last_drop);a.name = "last_drop";return a }
        # hash[:last_drop] = lambda { a = Logic.new(last_drop);a.name = "last_drop";return a }
        raise TdlError.new('idata_pool_axi4 Logic last_drop TdlHash cant include Proc') if last_drop.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(last_drop)
            unless last_drop[:name]
                a.name = "last_drop"
            end
            return a }
        hash.[]=(:last_drop,lam,false)
    end
            

    unless data.is_a? Hash
        hash.case_record(:data,data)
    else
        # hash.new_index(:data)= lambda { a = Logic.new(data);a.name = "data";return a }
        # hash[:data] = lambda { a = Logic.new(data);a.name = "data";return a }
        raise TdlError.new('idata_pool_axi4 Logic data TdlHash cant include Proc') if data.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(data)
            unless data[:name]
                a.name = "data"
            end
            return a }
        hash.[]=(:data,lam,false)
    end
            

    unless empty.is_a? Hash
        hash.case_record(:empty,empty)
    else
        # hash.new_index(:empty)= lambda { a = Logic.new(empty);a.name = "empty";return a }
        # hash[:empty] = lambda { a = Logic.new(empty);a.name = "empty";return a }
        raise TdlError.new('idata_pool_axi4 Logic empty TdlHash cant include Proc') if empty.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(empty)
            unless empty[:name]
                a.name = "empty"
            end
            return a }
        hash.[]=(:empty,lam,false)
    end
            

    unless wr_en.is_a? Hash
        hash.case_record(:wr_en,wr_en)
    else
        # hash.new_index(:wr_en)= lambda { a = Logic.new(wr_en);a.name = "wr_en";return a }
        # hash[:wr_en] = lambda { a = Logic.new(wr_en);a.name = "wr_en";return a }
        raise TdlError.new('idata_pool_axi4 Logic wr_en TdlHash cant include Proc') if wr_en.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(wr_en)
            unless wr_en[:name]
                a.name = "wr_en"
            end
            return a }
        hash.[]=(:wr_en,lam,false)
    end
            

    unless sewage_valve.is_a? Hash
        hash.case_record(:sewage_valve,sewage_valve)
    else
        # hash.new_index(:sewage_valve)= lambda { a = Logic.new(sewage_valve);a.name = "sewage_valve";return a }
        # hash[:sewage_valve] = lambda { a = Logic.new(sewage_valve);a.name = "sewage_valve";return a }
        raise TdlError.new('idata_pool_axi4 Logic sewage_valve TdlHash cant include Proc') if sewage_valve.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(sewage_valve)
            unless sewage_valve[:name]
                a.name = "sewage_valve"
            end
            return a }
        hash.[]=(:sewage_valve,lam,false)
    end
            

    unless axi_master.is_a? Hash
        hash.case_record(:axi_master,axi_master)
    else
        # hash.new_index(:axi_master)= lambda { a = Axi4.new(axi_master);a.name = "axi_master";return a }
        # hash[:axi_master] = lambda { a = Axi4.new(axi_master);a.name = "axi_master";return a }
        raise TdlError.new('idata_pool_axi4 Axi4 axi_master TdlHash cant include Proc') if axi_master.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Axi4.new(axi_master)
            unless axi_master[:name]
                a.name = "axi_master"
            end
            return a }
        hash.[]=(:axi_master,lam,false)
    end
            

    hash.push_to_module_stack(Axi4,:idata_pool_axi4)
    hash.open_error = true
    return hash
end
inst_independent_clock_fifo( depth:4, dsize:8, wr_clk:"wr_clk", wr_rst_n:"wr_rst_n", rd_clk:"rd_clk", rd_rst_n:"rd_rst_n", wdata:"wdata", wr_en:"wr_en", rdata:"rdata", rd_en:"rd_en", empty:"empty", full:"full") click to toggle source
# File lib/tdl/data_inf/bak/independent_clock_fifo_auto.rb, line 87
def Tdl.inst_independent_clock_fifo(
    depth:4,
    dsize:8,
    wr_clk:"wr_clk",
    wr_rst_n:"wr_rst_n",
    rd_clk:"rd_clk",
    rd_rst_n:"rd_rst_n",
    wdata:"wdata",
    wr_en:"wr_en",
    rdata:"rdata",
    rd_en:"rd_en",
    empty:"empty",
    full:"full")
    hash = TdlHash.new
    
    unless depth.is_a? Hash
        hash.case_record(:depth,depth)
    else
        # hash.new_index(:depth)= lambda { a = Parameter.new(depth);a.name = "depth";return a }
        # hash[:depth] = lambda { a = Parameter.new(depth);a.name = "depth";return a }
        raise TdlError.new('independent_clock_fifo Parameter depth TdlHash cant include Proc') if depth.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(depth)
            unless depth[:name]
                a.name = "depth"
            end
            return a }
        hash.[]=(:depth,lam,false)
    end
            

    unless dsize.is_a? Hash
        hash.case_record(:dsize,dsize)
    else
        # hash.new_index(:dsize)= lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        # hash[:dsize] = lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        raise TdlError.new('independent_clock_fifo Parameter dsize TdlHash cant include Proc') if dsize.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(dsize)
            unless dsize[:name]
                a.name = "dsize"
            end
            return a }
        hash.[]=(:dsize,lam,false)
    end
            

    unless wr_clk.is_a? Hash
        hash.case_record(:wr_clk,wr_clk)
    else
        # hash.new_index(:wr_clk)= lambda { a = Logic.new(wr_clk);a.name = "wr_clk";return a }
        # hash[:wr_clk] = lambda { a = Logic.new(wr_clk);a.name = "wr_clk";return a }
        raise TdlError.new('independent_clock_fifo Logic wr_clk TdlHash cant include Proc') if wr_clk.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(wr_clk)
            unless wr_clk[:name]
                a.name = "wr_clk"
            end
            return a }
        hash.[]=(:wr_clk,lam,false)
    end
            

    unless wr_rst_n.is_a? Hash
        hash.case_record(:wr_rst_n,wr_rst_n)
    else
        # hash.new_index(:wr_rst_n)= lambda { a = Logic.new(wr_rst_n);a.name = "wr_rst_n";return a }
        # hash[:wr_rst_n] = lambda { a = Logic.new(wr_rst_n);a.name = "wr_rst_n";return a }
        raise TdlError.new('independent_clock_fifo Logic wr_rst_n TdlHash cant include Proc') if wr_rst_n.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(wr_rst_n)
            unless wr_rst_n[:name]
                a.name = "wr_rst_n"
            end
            return a }
        hash.[]=(:wr_rst_n,lam,false)
    end
            

    unless rd_clk.is_a? Hash
        hash.case_record(:rd_clk,rd_clk)
    else
        # hash.new_index(:rd_clk)= lambda { a = Logic.new(rd_clk);a.name = "rd_clk";return a }
        # hash[:rd_clk] = lambda { a = Logic.new(rd_clk);a.name = "rd_clk";return a }
        raise TdlError.new('independent_clock_fifo Logic rd_clk TdlHash cant include Proc') if rd_clk.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(rd_clk)
            unless rd_clk[:name]
                a.name = "rd_clk"
            end
            return a }
        hash.[]=(:rd_clk,lam,false)
    end
            

    unless rd_rst_n.is_a? Hash
        hash.case_record(:rd_rst_n,rd_rst_n)
    else
        # hash.new_index(:rd_rst_n)= lambda { a = Logic.new(rd_rst_n);a.name = "rd_rst_n";return a }
        # hash[:rd_rst_n] = lambda { a = Logic.new(rd_rst_n);a.name = "rd_rst_n";return a }
        raise TdlError.new('independent_clock_fifo Logic rd_rst_n TdlHash cant include Proc') if rd_rst_n.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(rd_rst_n)
            unless rd_rst_n[:name]
                a.name = "rd_rst_n"
            end
            return a }
        hash.[]=(:rd_rst_n,lam,false)
    end
            

    unless wdata.is_a? Hash
        hash.case_record(:wdata,wdata)
    else
        # hash.new_index(:wdata)= lambda { a = Logic.new(wdata);a.name = "wdata";return a }
        # hash[:wdata] = lambda { a = Logic.new(wdata);a.name = "wdata";return a }
        raise TdlError.new('independent_clock_fifo Logic wdata TdlHash cant include Proc') if wdata.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(wdata)
            unless wdata[:name]
                a.name = "wdata"
            end
            return a }
        hash.[]=(:wdata,lam,false)
    end
            

    unless wr_en.is_a? Hash
        hash.case_record(:wr_en,wr_en)
    else
        # hash.new_index(:wr_en)= lambda { a = Logic.new(wr_en);a.name = "wr_en";return a }
        # hash[:wr_en] = lambda { a = Logic.new(wr_en);a.name = "wr_en";return a }
        raise TdlError.new('independent_clock_fifo Logic wr_en TdlHash cant include Proc') if wr_en.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(wr_en)
            unless wr_en[:name]
                a.name = "wr_en"
            end
            return a }
        hash.[]=(:wr_en,lam,false)
    end
            

    unless rdata.is_a? Hash
        hash.case_record(:rdata,rdata)
    else
        # hash.new_index(:rdata)= lambda { a = Logic.new(rdata);a.name = "rdata";return a }
        # hash[:rdata] = lambda { a = Logic.new(rdata);a.name = "rdata";return a }
        raise TdlError.new('independent_clock_fifo Logic rdata TdlHash cant include Proc') if rdata.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(rdata)
            unless rdata[:name]
                a.name = "rdata"
            end
            return a }
        hash.[]=(:rdata,lam,false)
    end
            

    unless rd_en.is_a? Hash
        hash.case_record(:rd_en,rd_en)
    else
        # hash.new_index(:rd_en)= lambda { a = Logic.new(rd_en);a.name = "rd_en";return a }
        # hash[:rd_en] = lambda { a = Logic.new(rd_en);a.name = "rd_en";return a }
        raise TdlError.new('independent_clock_fifo Logic rd_en TdlHash cant include Proc') if rd_en.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(rd_en)
            unless rd_en[:name]
                a.name = "rd_en"
            end
            return a }
        hash.[]=(:rd_en,lam,false)
    end
            

    unless empty.is_a? Hash
        hash.case_record(:empty,empty)
    else
        # hash.new_index(:empty)= lambda { a = Logic.new(empty);a.name = "empty";return a }
        # hash[:empty] = lambda { a = Logic.new(empty);a.name = "empty";return a }
        raise TdlError.new('independent_clock_fifo Logic empty TdlHash cant include Proc') if empty.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(empty)
            unless empty[:name]
                a.name = "empty"
            end
            return a }
        hash.[]=(:empty,lam,false)
    end
            

    unless full.is_a? Hash
        hash.case_record(:full,full)
    else
        # hash.new_index(:full)= lambda { a = Logic.new(full);a.name = "full";return a }
        # hash[:full] = lambda { a = Logic.new(full);a.name = "full";return a }
        raise TdlError.new('independent_clock_fifo Logic full TdlHash cant include Proc') if full.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(full)
            unless full[:name]
                a.name = "full"
            end
            return a }
        hash.[]=(:full,lam,false)
    end
            

    hash.push_to_module_stack(DataInf,:independent_clock_fifo)
    hash.open_error = true
    return hash
end
inst_jtag_to_axilite_wrapper( lite:"lite") { |hash| ... } click to toggle source
# File lib/tdl/axi_lite/bak/jtag_to_axilite_wrapper_auto.rb, line 84
def Tdl.inst_jtag_to_axilite_wrapper(
    lite:"lite")
    hash = TdlHash.new
    
    unless lite.is_a? Hash
        hash.case_record(:lite,lite)
    else
        # hash.new_index(:lite)= lambda { a = AxiLite.new(lite);a.name = "lite";return a }
        # hash[:lite] = lambda { a = AxiLite.new(lite);a.name = "lite";return a }
        raise TdlError.new('jtag_to_axilite_wrapper AxiLite lite TdlHash cant include Proc') if lite.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiLite.new(lite)
            unless lite[:name]
                a.name = "lite"
            end
            return a }
        hash.[]=(:lite,lam,false)
    end
            

    if block_given?
        yield hash
    end

    hash.push_to_module_stack(AxiLite,:jtag_to_axilite_wrapper)
    hash.open_error = true
    return hash
end
inst_odata_pool_axi4( dsize:8, rd_clk:"rd_clk", rd_rst_n:"rd_rst_n", data:"data", empty:"empty", rd_en:"rd_en", source_addr:"source_addr", size:"size", valid:"valid", ready:"ready", last_drop:"last_drop", axi_master:"axi_master") click to toggle source
# File lib/tdl/axi4/bak/odata_pool_axi4_auto.rb, line 175
def Tdl.inst_odata_pool_axi4(
    dsize:8,
    rd_clk:"rd_clk",
    rd_rst_n:"rd_rst_n",
    data:"data",
    empty:"empty",
    rd_en:"rd_en",
    source_addr:"source_addr",
    size:"size",
    valid:"valid",
    ready:"ready",
    last_drop:"last_drop",
    axi_master:"axi_master")
    hash = TdlHash.new
    
    unless dsize.is_a? Hash
        hash.case_record(:dsize,dsize)
    else
        # hash.new_index(:dsize)= lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        # hash[:dsize] = lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        raise TdlError.new('odata_pool_axi4 Parameter dsize TdlHash cant include Proc') if dsize.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(dsize)
            unless dsize[:name]
                a.name = "dsize"
            end
            return a }
        hash.[]=(:dsize,lam,false)
    end
            

    unless rd_clk.is_a? Hash
        hash.case_record(:rd_clk,rd_clk)
    else
        # hash.new_index(:rd_clk)= lambda { a = Logic.new(rd_clk);a.name = "rd_clk";return a }
        # hash[:rd_clk] = lambda { a = Logic.new(rd_clk);a.name = "rd_clk";return a }
        raise TdlError.new('odata_pool_axi4 Logic rd_clk TdlHash cant include Proc') if rd_clk.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(rd_clk)
            unless rd_clk[:name]
                a.name = "rd_clk"
            end
            return a }
        hash.[]=(:rd_clk,lam,false)
    end
            

    unless rd_rst_n.is_a? Hash
        hash.case_record(:rd_rst_n,rd_rst_n)
    else
        # hash.new_index(:rd_rst_n)= lambda { a = Logic.new(rd_rst_n);a.name = "rd_rst_n";return a }
        # hash[:rd_rst_n] = lambda { a = Logic.new(rd_rst_n);a.name = "rd_rst_n";return a }
        raise TdlError.new('odata_pool_axi4 Logic rd_rst_n TdlHash cant include Proc') if rd_rst_n.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(rd_rst_n)
            unless rd_rst_n[:name]
                a.name = "rd_rst_n"
            end
            return a }
        hash.[]=(:rd_rst_n,lam,false)
    end
            

    unless data.is_a? Hash
        hash.case_record(:data,data)
    else
        # hash.new_index(:data)= lambda { a = Logic.new(data);a.name = "data";return a }
        # hash[:data] = lambda { a = Logic.new(data);a.name = "data";return a }
        raise TdlError.new('odata_pool_axi4 Logic data TdlHash cant include Proc') if data.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(data)
            unless data[:name]
                a.name = "data"
            end
            return a }
        hash.[]=(:data,lam,false)
    end
            

    unless empty.is_a? Hash
        hash.case_record(:empty,empty)
    else
        # hash.new_index(:empty)= lambda { a = Logic.new(empty);a.name = "empty";return a }
        # hash[:empty] = lambda { a = Logic.new(empty);a.name = "empty";return a }
        raise TdlError.new('odata_pool_axi4 Logic empty TdlHash cant include Proc') if empty.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(empty)
            unless empty[:name]
                a.name = "empty"
            end
            return a }
        hash.[]=(:empty,lam,false)
    end
            

    unless rd_en.is_a? Hash
        hash.case_record(:rd_en,rd_en)
    else
        # hash.new_index(:rd_en)= lambda { a = Logic.new(rd_en);a.name = "rd_en";return a }
        # hash[:rd_en] = lambda { a = Logic.new(rd_en);a.name = "rd_en";return a }
        raise TdlError.new('odata_pool_axi4 Logic rd_en TdlHash cant include Proc') if rd_en.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(rd_en)
            unless rd_en[:name]
                a.name = "rd_en"
            end
            return a }
        hash.[]=(:rd_en,lam,false)
    end
            

    unless source_addr.is_a? Hash
        hash.case_record(:source_addr,source_addr)
    else
        # hash.new_index(:source_addr)= lambda { a = Logic.new(source_addr);a.name = "source_addr";return a }
        # hash[:source_addr] = lambda { a = Logic.new(source_addr);a.name = "source_addr";return a }
        raise TdlError.new('odata_pool_axi4 Logic source_addr TdlHash cant include Proc') if source_addr.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(source_addr)
            unless source_addr[:name]
                a.name = "source_addr"
            end
            return a }
        hash.[]=(:source_addr,lam,false)
    end
            

    unless size.is_a? Hash
        hash.case_record(:size,size)
    else
        # hash.new_index(:size)= lambda { a = Logic.new(size);a.name = "size";return a }
        # hash[:size] = lambda { a = Logic.new(size);a.name = "size";return a }
        raise TdlError.new('odata_pool_axi4 Logic size TdlHash cant include Proc') if size.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(size)
            unless size[:name]
                a.name = "size"
            end
            return a }
        hash.[]=(:size,lam,false)
    end
            

    unless valid.is_a? Hash
        hash.case_record(:valid,valid)
    else
        # hash.new_index(:valid)= lambda { a = Logic.new(valid);a.name = "valid";return a }
        # hash[:valid] = lambda { a = Logic.new(valid);a.name = "valid";return a }
        raise TdlError.new('odata_pool_axi4 Logic valid TdlHash cant include Proc') if valid.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(valid)
            unless valid[:name]
                a.name = "valid"
            end
            return a }
        hash.[]=(:valid,lam,false)
    end
            

    unless ready.is_a? Hash
        hash.case_record(:ready,ready)
    else
        # hash.new_index(:ready)= lambda { a = Logic.new(ready);a.name = "ready";return a }
        # hash[:ready] = lambda { a = Logic.new(ready);a.name = "ready";return a }
        raise TdlError.new('odata_pool_axi4 Logic ready TdlHash cant include Proc') if ready.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(ready)
            unless ready[:name]
                a.name = "ready"
            end
            return a }
        hash.[]=(:ready,lam,false)
    end
            

    unless last_drop.is_a? Hash
        hash.case_record(:last_drop,last_drop)
    else
        # hash.new_index(:last_drop)= lambda { a = Logic.new(last_drop);a.name = "last_drop";return a }
        # hash[:last_drop] = lambda { a = Logic.new(last_drop);a.name = "last_drop";return a }
        raise TdlError.new('odata_pool_axi4 Logic last_drop TdlHash cant include Proc') if last_drop.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(last_drop)
            unless last_drop[:name]
                a.name = "last_drop"
            end
            return a }
        hash.[]=(:last_drop,lam,false)
    end
            

    unless axi_master.is_a? Hash
        hash.case_record(:axi_master,axi_master)
    else
        # hash.new_index(:axi_master)= lambda { a = Axi4.new(axi_master);a.name = "axi_master";return a }
        # hash[:axi_master] = lambda { a = Axi4.new(axi_master);a.name = "axi_master";return a }
        raise TdlError.new('odata_pool_axi4 Axi4 axi_master TdlHash cant include Proc') if axi_master.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Axi4.new(axi_master)
            unless axi_master[:name]
                a.name = "axi_master"
            end
            return a }
        hash.[]=(:axi_master,lam,false)
    end
            

    hash.push_to_module_stack(Axi4,:odata_pool_axi4)
    hash.open_error = true
    return hash
end
inst_odata_pool_axi4_a1( source_addr:"source_addr", size:"size", valid:"valid", ready:"ready", out_axis:"out_axis", axi_master:"axi_master") click to toggle source
# File lib/tdl/axi4/bak/odata_pool_axi4_A1_auto.rb, line 121
def Tdl.inst_odata_pool_axi4_a1(
    source_addr:"source_addr",
    size:"size",
    valid:"valid",
    ready:"ready",
    out_axis:"out_axis",
    axi_master:"axi_master")
    hash = TdlHash.new
    
    unless source_addr.is_a? Hash
        hash.case_record(:source_addr,source_addr)
    else
        # hash.new_index(:source_addr)= lambda { a = Logic.new(source_addr);a.name = "source_addr";return a }
        # hash[:source_addr] = lambda { a = Logic.new(source_addr);a.name = "source_addr";return a }
        raise TdlError.new('odata_pool_axi4_a1 Logic source_addr TdlHash cant include Proc') if source_addr.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(source_addr)
            unless source_addr[:name]
                a.name = "source_addr"
            end
            return a }
        hash.[]=(:source_addr,lam,false)
    end
            

    unless size.is_a? Hash
        hash.case_record(:size,size)
    else
        # hash.new_index(:size)= lambda { a = Logic.new(size);a.name = "size";return a }
        # hash[:size] = lambda { a = Logic.new(size);a.name = "size";return a }
        raise TdlError.new('odata_pool_axi4_a1 Logic size TdlHash cant include Proc') if size.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(size)
            unless size[:name]
                a.name = "size"
            end
            return a }
        hash.[]=(:size,lam,false)
    end
            

    unless valid.is_a? Hash
        hash.case_record(:valid,valid)
    else
        # hash.new_index(:valid)= lambda { a = Logic.new(valid);a.name = "valid";return a }
        # hash[:valid] = lambda { a = Logic.new(valid);a.name = "valid";return a }
        raise TdlError.new('odata_pool_axi4_a1 Logic valid TdlHash cant include Proc') if valid.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(valid)
            unless valid[:name]
                a.name = "valid"
            end
            return a }
        hash.[]=(:valid,lam,false)
    end
            

    unless ready.is_a? Hash
        hash.case_record(:ready,ready)
    else
        # hash.new_index(:ready)= lambda { a = Logic.new(ready);a.name = "ready";return a }
        # hash[:ready] = lambda { a = Logic.new(ready);a.name = "ready";return a }
        raise TdlError.new('odata_pool_axi4_a1 Logic ready TdlHash cant include Proc') if ready.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(ready)
            unless ready[:name]
                a.name = "ready"
            end
            return a }
        hash.[]=(:ready,lam,false)
    end
            

    unless out_axis.is_a? Hash
        hash.case_record(:out_axis,out_axis)
    else
        # hash.new_index(:out_axis)= lambda { a = AxiStream.new(out_axis);a.name = "out_axis";return a }
        # hash[:out_axis] = lambda { a = AxiStream.new(out_axis);a.name = "out_axis";return a }
        raise TdlError.new('odata_pool_axi4_a1 AxiStream out_axis TdlHash cant include Proc') if out_axis.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(out_axis)
            unless out_axis[:name]
                a.name = "out_axis"
            end
            return a }
        hash.[]=(:out_axis,lam,false)
    end
            

    unless axi_master.is_a? Hash
        hash.case_record(:axi_master,axi_master)
    else
        # hash.new_index(:axi_master)= lambda { a = Axi4.new(axi_master);a.name = "axi_master";return a }
        # hash[:axi_master] = lambda { a = Axi4.new(axi_master);a.name = "axi_master";return a }
        raise TdlError.new('odata_pool_axi4_a1 Axi4 axi_master TdlHash cant include Proc') if axi_master.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Axi4.new(axi_master)
            unless axi_master[:name]
                a.name = "axi_master"
            end
            return a }
        hash.[]=(:axi_master,lam,false)
    end
            

    hash.push_to_module_stack(Axi4,:odata_pool_axi4_a1)
    hash.open_error = true
    return hash
end
inst_parse_big_field_table( dsize:8, field_len:16*8, field_name:"Big Filed", try_parse:"OFF", enable:"enable", value:"value", out_valid:"out_valid", cm_tb_s:"cm_tb_s", cm_tb_m:"cm_tb_m", cm_mirror:"cm_mirror") click to toggle source
# File lib/tdl/axi_stream/bak/parse_big_field_table_auto.rb, line 115
def Tdl.inst_parse_big_field_table(
    dsize:8,
    field_len:16*8,
    field_name:"Big Filed",
    try_parse:"OFF",
    enable:"enable",
    value:"value",
    out_valid:"out_valid",
    cm_tb_s:"cm_tb_s",
    cm_tb_m:"cm_tb_m",
    cm_mirror:"cm_mirror")
    hash = TdlHash.new
    
    unless dsize.is_a? Hash
        hash.case_record(:dsize,dsize)
    else
        # hash.new_index(:dsize)= lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        # hash[:dsize] = lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        raise TdlError.new('parse_big_field_table Parameter dsize TdlHash cant include Proc') if dsize.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(dsize)
            unless dsize[:name]
                a.name = "dsize"
            end
            return a }
        hash.[]=(:dsize,lam,false)
    end
            

    unless field_len.is_a? Hash
        hash.case_record(:field_len,field_len)
    else
        # hash.new_index(:field_len)= lambda { a = Parameter.new(field_len);a.name = "field_len";return a }
        # hash[:field_len] = lambda { a = Parameter.new(field_len);a.name = "field_len";return a }
        raise TdlError.new('parse_big_field_table Parameter field_len TdlHash cant include Proc') if field_len.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(field_len)
            unless field_len[:name]
                a.name = "field_len"
            end
            return a }
        hash.[]=(:field_len,lam,false)
    end
            

    unless field_name.is_a? Hash
        hash.case_record(:field_name,field_name)
    else
        # hash.new_index(:field_name)= lambda { a = Parameter.new(field_name);a.name = "field_name";return a }
        # hash[:field_name] = lambda { a = Parameter.new(field_name);a.name = "field_name";return a }
        raise TdlError.new('parse_big_field_table Parameter field_name TdlHash cant include Proc') if field_name.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(field_name)
            unless field_name[:name]
                a.name = "field_name"
            end
            return a }
        hash.[]=(:field_name,lam,false)
    end
            

    unless try_parse.is_a? Hash
        hash.case_record(:try_parse,try_parse)
    else
        # hash.new_index(:try_parse)= lambda { a = Parameter.new(try_parse);a.name = "try_parse";return a }
        # hash[:try_parse] = lambda { a = Parameter.new(try_parse);a.name = "try_parse";return a }
        raise TdlError.new('parse_big_field_table Parameter try_parse TdlHash cant include Proc') if try_parse.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(try_parse)
            unless try_parse[:name]
                a.name = "try_parse"
            end
            return a }
        hash.[]=(:try_parse,lam,false)
    end
            

    unless enable.is_a? Hash
        hash.case_record(:enable,enable)
    else
        # hash.new_index(:enable)= lambda { a = Logic.new(enable);a.name = "enable";return a }
        # hash[:enable] = lambda { a = Logic.new(enable);a.name = "enable";return a }
        raise TdlError.new('parse_big_field_table Logic enable TdlHash cant include Proc') if enable.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(enable)
            unless enable[:name]
                a.name = "enable"
            end
            return a }
        hash.[]=(:enable,lam,false)
    end
            

    unless value.is_a? Hash
        hash.case_record(:value,value)
    else
        # hash.new_index(:value)= lambda { a = Logic.new(value);a.name = "value";return a }
        # hash[:value] = lambda { a = Logic.new(value);a.name = "value";return a }
        raise TdlError.new('parse_big_field_table Logic value TdlHash cant include Proc') if value.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(value)
            unless value[:name]
                a.name = "value"
            end
            return a }
        hash.[]=(:value,lam,false)
    end
            

    unless out_valid.is_a? Hash
        hash.case_record(:out_valid,out_valid)
    else
        # hash.new_index(:out_valid)= lambda { a = Logic.new(out_valid);a.name = "out_valid";return a }
        # hash[:out_valid] = lambda { a = Logic.new(out_valid);a.name = "out_valid";return a }
        raise TdlError.new('parse_big_field_table Logic out_valid TdlHash cant include Proc') if out_valid.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(out_valid)
            unless out_valid[:name]
                a.name = "out_valid"
            end
            return a }
        hash.[]=(:out_valid,lam,false)
    end
            

    unless cm_tb_s.is_a? Hash
        hash.case_record(:cm_tb_s,cm_tb_s)
    else
        # hash.new_index(:cm_tb_s)= lambda { a = AxiStream.new(cm_tb_s);a.name = "cm_tb_s";return a }
        # hash[:cm_tb_s] = lambda { a = AxiStream.new(cm_tb_s);a.name = "cm_tb_s";return a }
        raise TdlError.new('parse_big_field_table AxiStream cm_tb_s TdlHash cant include Proc') if cm_tb_s.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(cm_tb_s)
            unless cm_tb_s[:name]
                a.name = "cm_tb_s"
            end
            return a }
        hash.[]=(:cm_tb_s,lam,false)
    end
            

    unless cm_tb_m.is_a? Hash
        hash.case_record(:cm_tb_m,cm_tb_m)
    else
        # hash.new_index(:cm_tb_m)= lambda { a = AxiStream.new(cm_tb_m);a.name = "cm_tb_m";return a }
        # hash[:cm_tb_m] = lambda { a = AxiStream.new(cm_tb_m);a.name = "cm_tb_m";return a }
        raise TdlError.new('parse_big_field_table AxiStream cm_tb_m TdlHash cant include Proc') if cm_tb_m.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(cm_tb_m)
            unless cm_tb_m[:name]
                a.name = "cm_tb_m"
            end
            return a }
        hash.[]=(:cm_tb_m,lam,false)
    end
            

    unless cm_mirror.is_a? Hash
        hash.case_record(:cm_mirror,cm_mirror)
    else
        # hash.new_index(:cm_mirror)= lambda { a = AxiStream.new(cm_mirror);a.name = "cm_mirror";return a }
        # hash[:cm_mirror] = lambda { a = AxiStream.new(cm_mirror);a.name = "cm_mirror";return a }
        raise TdlError.new('parse_big_field_table AxiStream cm_mirror TdlHash cant include Proc') if cm_mirror.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(cm_mirror)
            unless cm_mirror[:name]
                a.name = "cm_mirror"
            end
            return a }
        hash.[]=(:cm_mirror,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:parse_big_field_table)
    hash.open_error = true
    return hash
end
inst_parse_big_field_table_a1( dsize:8, field_len:16*8, field_name:"Big Filed", try_parse:"OFF", enable:"enable", value:"value", out_valid:"out_valid", cm_tb_s:"cm_tb_s", cm_tb_m:"cm_tb_m", cm_mirror:"cm_mirror") click to toggle source
# File lib/tdl/axi_stream/bak/parse_big_field_table_A1_auto.rb, line 115
def Tdl.inst_parse_big_field_table_a1(
    dsize:8,
    field_len:16*8,
    field_name:"Big Filed",
    try_parse:"OFF",
    enable:"enable",
    value:"value",
    out_valid:"out_valid",
    cm_tb_s:"cm_tb_s",
    cm_tb_m:"cm_tb_m",
    cm_mirror:"cm_mirror")
    hash = TdlHash.new
    
    unless dsize.is_a? Hash
        hash.case_record(:dsize,dsize)
    else
        # hash.new_index(:dsize)= lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        # hash[:dsize] = lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        raise TdlError.new('parse_big_field_table_a1 Parameter dsize TdlHash cant include Proc') if dsize.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(dsize)
            unless dsize[:name]
                a.name = "dsize"
            end
            return a }
        hash.[]=(:dsize,lam,false)
    end
            

    unless field_len.is_a? Hash
        hash.case_record(:field_len,field_len)
    else
        # hash.new_index(:field_len)= lambda { a = Parameter.new(field_len);a.name = "field_len";return a }
        # hash[:field_len] = lambda { a = Parameter.new(field_len);a.name = "field_len";return a }
        raise TdlError.new('parse_big_field_table_a1 Parameter field_len TdlHash cant include Proc') if field_len.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(field_len)
            unless field_len[:name]
                a.name = "field_len"
            end
            return a }
        hash.[]=(:field_len,lam,false)
    end
            

    unless field_name.is_a? Hash
        hash.case_record(:field_name,field_name)
    else
        # hash.new_index(:field_name)= lambda { a = Parameter.new(field_name);a.name = "field_name";return a }
        # hash[:field_name] = lambda { a = Parameter.new(field_name);a.name = "field_name";return a }
        raise TdlError.new('parse_big_field_table_a1 Parameter field_name TdlHash cant include Proc') if field_name.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(field_name)
            unless field_name[:name]
                a.name = "field_name"
            end
            return a }
        hash.[]=(:field_name,lam,false)
    end
            

    unless try_parse.is_a? Hash
        hash.case_record(:try_parse,try_parse)
    else
        # hash.new_index(:try_parse)= lambda { a = Parameter.new(try_parse);a.name = "try_parse";return a }
        # hash[:try_parse] = lambda { a = Parameter.new(try_parse);a.name = "try_parse";return a }
        raise TdlError.new('parse_big_field_table_a1 Parameter try_parse TdlHash cant include Proc') if try_parse.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(try_parse)
            unless try_parse[:name]
                a.name = "try_parse"
            end
            return a }
        hash.[]=(:try_parse,lam,false)
    end
            

    unless enable.is_a? Hash
        hash.case_record(:enable,enable)
    else
        # hash.new_index(:enable)= lambda { a = Logic.new(enable);a.name = "enable";return a }
        # hash[:enable] = lambda { a = Logic.new(enable);a.name = "enable";return a }
        raise TdlError.new('parse_big_field_table_a1 Logic enable TdlHash cant include Proc') if enable.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(enable)
            unless enable[:name]
                a.name = "enable"
            end
            return a }
        hash.[]=(:enable,lam,false)
    end
            

    unless value.is_a? Hash
        hash.case_record(:value,value)
    else
        # hash.new_index(:value)= lambda { a = Logic.new(value);a.name = "value";return a }
        # hash[:value] = lambda { a = Logic.new(value);a.name = "value";return a }
        raise TdlError.new('parse_big_field_table_a1 Logic value TdlHash cant include Proc') if value.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(value)
            unless value[:name]
                a.name = "value"
            end
            return a }
        hash.[]=(:value,lam,false)
    end
            

    unless out_valid.is_a? Hash
        hash.case_record(:out_valid,out_valid)
    else
        # hash.new_index(:out_valid)= lambda { a = Logic.new(out_valid);a.name = "out_valid";return a }
        # hash[:out_valid] = lambda { a = Logic.new(out_valid);a.name = "out_valid";return a }
        raise TdlError.new('parse_big_field_table_a1 Logic out_valid TdlHash cant include Proc') if out_valid.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(out_valid)
            unless out_valid[:name]
                a.name = "out_valid"
            end
            return a }
        hash.[]=(:out_valid,lam,false)
    end
            

    unless cm_tb_s.is_a? Hash
        hash.case_record(:cm_tb_s,cm_tb_s)
    else
        # hash.new_index(:cm_tb_s)= lambda { a = AxiStream.new(cm_tb_s);a.name = "cm_tb_s";return a }
        # hash[:cm_tb_s] = lambda { a = AxiStream.new(cm_tb_s);a.name = "cm_tb_s";return a }
        raise TdlError.new('parse_big_field_table_a1 AxiStream cm_tb_s TdlHash cant include Proc') if cm_tb_s.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(cm_tb_s)
            unless cm_tb_s[:name]
                a.name = "cm_tb_s"
            end
            return a }
        hash.[]=(:cm_tb_s,lam,false)
    end
            

    unless cm_tb_m.is_a? Hash
        hash.case_record(:cm_tb_m,cm_tb_m)
    else
        # hash.new_index(:cm_tb_m)= lambda { a = AxiStream.new(cm_tb_m);a.name = "cm_tb_m";return a }
        # hash[:cm_tb_m] = lambda { a = AxiStream.new(cm_tb_m);a.name = "cm_tb_m";return a }
        raise TdlError.new('parse_big_field_table_a1 AxiStream cm_tb_m TdlHash cant include Proc') if cm_tb_m.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(cm_tb_m)
            unless cm_tb_m[:name]
                a.name = "cm_tb_m"
            end
            return a }
        hash.[]=(:cm_tb_m,lam,false)
    end
            

    unless cm_mirror.is_a? Hash
        hash.case_record(:cm_mirror,cm_mirror)
    else
        # hash.new_index(:cm_mirror)= lambda { a = AxiStream.new(cm_mirror);a.name = "cm_mirror";return a }
        # hash[:cm_mirror] = lambda { a = AxiStream.new(cm_mirror);a.name = "cm_mirror";return a }
        raise TdlError.new('parse_big_field_table_a1 AxiStream cm_mirror TdlHash cant include Proc') if cm_mirror.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(cm_mirror)
            unless cm_mirror[:name]
                a.name = "cm_mirror"
            end
            return a }
        hash.[]=(:cm_mirror,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:parse_big_field_table_a1)
    hash.open_error = true
    return hash
end
inst_parse_big_field_table_a2( dsize:8, field_len:16*8, field_name:"Big Filed", try_parse:"OFF", enable:"enable", value:"value", out_valid:"out_valid", cm_tb_s:"cm_tb_s", cm_tb_m:"cm_tb_m", cm_mirror:"cm_mirror") click to toggle source
# File lib/tdl/axi_stream/bak/parse_big_field_table_A2_auto.rb, line 115
def Tdl.inst_parse_big_field_table_a2(
    dsize:8,
    field_len:16*8,
    field_name:"Big Filed",
    try_parse:"OFF",
    enable:"enable",
    value:"value",
    out_valid:"out_valid",
    cm_tb_s:"cm_tb_s",
    cm_tb_m:"cm_tb_m",
    cm_mirror:"cm_mirror")
    hash = TdlHash.new
    
    unless dsize.is_a? Hash
        hash.case_record(:dsize,dsize)
    else
        # hash.new_index(:dsize)= lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        # hash[:dsize] = lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        raise TdlError.new('parse_big_field_table_a2 Parameter dsize TdlHash cant include Proc') if dsize.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(dsize)
            unless dsize[:name]
                a.name = "dsize"
            end
            return a }
        hash.[]=(:dsize,lam,false)
    end
            

    unless field_len.is_a? Hash
        hash.case_record(:field_len,field_len)
    else
        # hash.new_index(:field_len)= lambda { a = Parameter.new(field_len);a.name = "field_len";return a }
        # hash[:field_len] = lambda { a = Parameter.new(field_len);a.name = "field_len";return a }
        raise TdlError.new('parse_big_field_table_a2 Parameter field_len TdlHash cant include Proc') if field_len.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(field_len)
            unless field_len[:name]
                a.name = "field_len"
            end
            return a }
        hash.[]=(:field_len,lam,false)
    end
            

    unless field_name.is_a? Hash
        hash.case_record(:field_name,field_name)
    else
        # hash.new_index(:field_name)= lambda { a = Parameter.new(field_name);a.name = "field_name";return a }
        # hash[:field_name] = lambda { a = Parameter.new(field_name);a.name = "field_name";return a }
        raise TdlError.new('parse_big_field_table_a2 Parameter field_name TdlHash cant include Proc') if field_name.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(field_name)
            unless field_name[:name]
                a.name = "field_name"
            end
            return a }
        hash.[]=(:field_name,lam,false)
    end
            

    unless try_parse.is_a? Hash
        hash.case_record(:try_parse,try_parse)
    else
        # hash.new_index(:try_parse)= lambda { a = Parameter.new(try_parse);a.name = "try_parse";return a }
        # hash[:try_parse] = lambda { a = Parameter.new(try_parse);a.name = "try_parse";return a }
        raise TdlError.new('parse_big_field_table_a2 Parameter try_parse TdlHash cant include Proc') if try_parse.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Parameter.new(try_parse)
            unless try_parse[:name]
                a.name = "try_parse"
            end
            return a }
        hash.[]=(:try_parse,lam,false)
    end
            

    unless enable.is_a? Hash
        hash.case_record(:enable,enable)
    else
        # hash.new_index(:enable)= lambda { a = Logic.new(enable);a.name = "enable";return a }
        # hash[:enable] = lambda { a = Logic.new(enable);a.name = "enable";return a }
        raise TdlError.new('parse_big_field_table_a2 Logic enable TdlHash cant include Proc') if enable.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(enable)
            unless enable[:name]
                a.name = "enable"
            end
            return a }
        hash.[]=(:enable,lam,false)
    end
            

    unless value.is_a? Hash
        hash.case_record(:value,value)
    else
        # hash.new_index(:value)= lambda { a = Logic.new(value);a.name = "value";return a }
        # hash[:value] = lambda { a = Logic.new(value);a.name = "value";return a }
        raise TdlError.new('parse_big_field_table_a2 Logic value TdlHash cant include Proc') if value.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(value)
            unless value[:name]
                a.name = "value"
            end
            return a }
        hash.[]=(:value,lam,false)
    end
            

    unless out_valid.is_a? Hash
        hash.case_record(:out_valid,out_valid)
    else
        # hash.new_index(:out_valid)= lambda { a = Logic.new(out_valid);a.name = "out_valid";return a }
        # hash[:out_valid] = lambda { a = Logic.new(out_valid);a.name = "out_valid";return a }
        raise TdlError.new('parse_big_field_table_a2 Logic out_valid TdlHash cant include Proc') if out_valid.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(out_valid)
            unless out_valid[:name]
                a.name = "out_valid"
            end
            return a }
        hash.[]=(:out_valid,lam,false)
    end
            

    unless cm_tb_s.is_a? Hash
        hash.case_record(:cm_tb_s,cm_tb_s)
    else
        # hash.new_index(:cm_tb_s)= lambda { a = AxiStream.new(cm_tb_s);a.name = "cm_tb_s";return a }
        # hash[:cm_tb_s] = lambda { a = AxiStream.new(cm_tb_s);a.name = "cm_tb_s";return a }
        raise TdlError.new('parse_big_field_table_a2 AxiStream cm_tb_s TdlHash cant include Proc') if cm_tb_s.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(cm_tb_s)
            unless cm_tb_s[:name]
                a.name = "cm_tb_s"
            end
            return a }
        hash.[]=(:cm_tb_s,lam,false)
    end
            

    unless cm_tb_m.is_a? Hash
        hash.case_record(:cm_tb_m,cm_tb_m)
    else
        # hash.new_index(:cm_tb_m)= lambda { a = AxiStream.new(cm_tb_m);a.name = "cm_tb_m";return a }
        # hash[:cm_tb_m] = lambda { a = AxiStream.new(cm_tb_m);a.name = "cm_tb_m";return a }
        raise TdlError.new('parse_big_field_table_a2 AxiStream cm_tb_m TdlHash cant include Proc') if cm_tb_m.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(cm_tb_m)
            unless cm_tb_m[:name]
                a.name = "cm_tb_m"
            end
            return a }
        hash.[]=(:cm_tb_m,lam,false)
    end
            

    unless cm_mirror.is_a? Hash
        hash.case_record(:cm_mirror,cm_mirror)
    else
        # hash.new_index(:cm_mirror)= lambda { a = AxiStream.new(cm_mirror);a.name = "cm_mirror";return a }
        # hash[:cm_mirror] = lambda { a = AxiStream.new(cm_mirror);a.name = "cm_mirror";return a }
        raise TdlError.new('parse_big_field_table_a2 AxiStream cm_mirror TdlHash cant include Proc') if cm_mirror.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(cm_mirror)
            unless cm_mirror[:name]
                a.name = "cm_mirror"
            end
            return a }
        hash.[]=(:cm_mirror,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:parse_big_field_table_a2)
    hash.open_error = true
    return hash
end
inst_part_data_pair_map(num:8, isize:8, osize:8, write_inf:"write_inf", ipart_inf:"ipart_inf", opart_inf:"opart_inf", idel_inf:"idel_inf", odel_inf:"odel_inf", oipart_inf:"oipart_inf", oopart_inf:"oopart_inf", ierr_inf:"ierr_inf", oerr_inf:"oerr_inf") click to toggle source
# File lib/tdl/axi_stream/bak/part_data_pair_map_auto.rb, line 82
def Tdl.inst_part_data_pair_map(num:8,
    isize:8,
    osize:8,
    write_inf:"write_inf",
    ipart_inf:"ipart_inf",
    opart_inf:"opart_inf",
    idel_inf:"idel_inf",
    odel_inf:"odel_inf",
    oipart_inf:"oipart_inf",
    oopart_inf:"oopart_inf",
    ierr_inf:"ierr_inf",
    oerr_inf:"oerr_inf")
    hash = TdlHash.new
    
    unless num.is_a? Hash
        # hash.new_index(:num) = num
        if num.is_a? BaseElm
            hash.[]=(:num,num,true)
        else
            hash.[]=(:num,num,false)
        end
    else
        # hash.new_index(:num)= lambda { a = Parameter.new(num);a.name = "num";return a }
        # hash[:num] = lambda { a = Parameter.new(num);a.name = "num";return a }
        lam = lambda {
            a = Parameter.new(num)
            unless num[:name]
                a.name = "num"
            end
            return a }
        hash.[]=(:num,lam,false)
    end
            

    unless isize.is_a? Hash
        # hash.new_index(:isize) = isize
        if isize.is_a? BaseElm
            hash.[]=(:isize,isize,true)
        else
            hash.[]=(:isize,isize,false)
        end
    else
        # hash.new_index(:isize)= lambda { a = Parameter.new(isize);a.name = "isize";return a }
        # hash[:isize] = lambda { a = Parameter.new(isize);a.name = "isize";return a }
        lam = lambda {
            a = Parameter.new(isize)
            unless isize[:name]
                a.name = "isize"
            end
            return a }
        hash.[]=(:isize,lam,false)
    end
            

    unless osize.is_a? Hash
        # hash.new_index(:osize) = osize
        if osize.is_a? BaseElm
            hash.[]=(:osize,osize,true)
        else
            hash.[]=(:osize,osize,false)
        end
    else
        # hash.new_index(:osize)= lambda { a = Parameter.new(osize);a.name = "osize";return a }
        # hash[:osize] = lambda { a = Parameter.new(osize);a.name = "osize";return a }
        lam = lambda {
            a = Parameter.new(osize)
            unless osize[:name]
                a.name = "osize"
            end
            return a }
        hash.[]=(:osize,lam,false)
    end
            

    unless write_inf.is_a? Hash
        # hash.new_index(:write_inf) = write_inf
        if write_inf.is_a? BaseElm
            hash.[]=(:write_inf,write_inf,true)
        else
            hash.[]=(:write_inf,write_inf,false)
        end
    else
        # hash.new_index(:write_inf)= lambda { a = DataInf_C.new(write_inf);a.name = "write_inf";return a }
        # hash[:write_inf] = lambda { a = DataInf_C.new(write_inf);a.name = "write_inf";return a }
        lam = lambda {
            a = DataInf_C.new(write_inf)
            unless write_inf[:name]
                a.name = "write_inf"
            end
            return a }
        hash.[]=(:write_inf,lam,false)
    end
            

    unless ipart_inf.is_a? Hash
        # hash.new_index(:ipart_inf) = ipart_inf
        if ipart_inf.is_a? BaseElm
            hash.[]=(:ipart_inf,ipart_inf,true)
        else
            hash.[]=(:ipart_inf,ipart_inf,false)
        end
    else
        # hash.new_index(:ipart_inf)= lambda { a = DataInf_C.new(ipart_inf);a.name = "ipart_inf";return a }
        # hash[:ipart_inf] = lambda { a = DataInf_C.new(ipart_inf);a.name = "ipart_inf";return a }
        lam = lambda {
            a = DataInf_C.new(ipart_inf)
            unless ipart_inf[:name]
                a.name = "ipart_inf"
            end
            return a }
        hash.[]=(:ipart_inf,lam,false)
    end
            

    unless opart_inf.is_a? Hash
        # hash.new_index(:opart_inf) = opart_inf
        if opart_inf.is_a? BaseElm
            hash.[]=(:opart_inf,opart_inf,true)
        else
            hash.[]=(:opart_inf,opart_inf,false)
        end
    else
        # hash.new_index(:opart_inf)= lambda { a = DataInf_C.new(opart_inf);a.name = "opart_inf";return a }
        # hash[:opart_inf] = lambda { a = DataInf_C.new(opart_inf);a.name = "opart_inf";return a }
        lam = lambda {
            a = DataInf_C.new(opart_inf)
            unless opart_inf[:name]
                a.name = "opart_inf"
            end
            return a }
        hash.[]=(:opart_inf,lam,false)
    end
            

    unless idel_inf.is_a? Hash
        # hash.new_index(:idel_inf) = idel_inf
        if idel_inf.is_a? BaseElm
            hash.[]=(:idel_inf,idel_inf,true)
        else
            hash.[]=(:idel_inf,idel_inf,false)
        end
    else
        # hash.new_index(:idel_inf)= lambda { a = DataInf_C.new(idel_inf);a.name = "idel_inf";return a }
        # hash[:idel_inf] = lambda { a = DataInf_C.new(idel_inf);a.name = "idel_inf";return a }
        lam = lambda {
            a = DataInf_C.new(idel_inf)
            unless idel_inf[:name]
                a.name = "idel_inf"
            end
            return a }
        hash.[]=(:idel_inf,lam,false)
    end
            

    unless odel_inf.is_a? Hash
        # hash.new_index(:odel_inf) = odel_inf
        if odel_inf.is_a? BaseElm
            hash.[]=(:odel_inf,odel_inf,true)
        else
            hash.[]=(:odel_inf,odel_inf,false)
        end
    else
        # hash.new_index(:odel_inf)= lambda { a = DataInf_C.new(odel_inf);a.name = "odel_inf";return a }
        # hash[:odel_inf] = lambda { a = DataInf_C.new(odel_inf);a.name = "odel_inf";return a }
        lam = lambda {
            a = DataInf_C.new(odel_inf)
            unless odel_inf[:name]
                a.name = "odel_inf"
            end
            return a }
        hash.[]=(:odel_inf,lam,false)
    end
            

    unless oipart_inf.is_a? Hash
        # hash.new_index(:oipart_inf) = oipart_inf
        if oipart_inf.is_a? BaseElm
            hash.[]=(:oipart_inf,oipart_inf,true)
        else
            hash.[]=(:oipart_inf,oipart_inf,false)
        end
    else
        # hash.new_index(:oipart_inf)= lambda { a = DataInf_C.new(oipart_inf);a.name = "oipart_inf";return a }
        # hash[:oipart_inf] = lambda { a = DataInf_C.new(oipart_inf);a.name = "oipart_inf";return a }
        lam = lambda {
            a = DataInf_C.new(oipart_inf)
            unless oipart_inf[:name]
                a.name = "oipart_inf"
            end
            return a }
        hash.[]=(:oipart_inf,lam,false)
    end
            

    unless oopart_inf.is_a? Hash
        # hash.new_index(:oopart_inf) = oopart_inf
        if oopart_inf.is_a? BaseElm
            hash.[]=(:oopart_inf,oopart_inf,true)
        else
            hash.[]=(:oopart_inf,oopart_inf,false)
        end
    else
        # hash.new_index(:oopart_inf)= lambda { a = DataInf_C.new(oopart_inf);a.name = "oopart_inf";return a }
        # hash[:oopart_inf] = lambda { a = DataInf_C.new(oopart_inf);a.name = "oopart_inf";return a }
        lam = lambda {
            a = DataInf_C.new(oopart_inf)
            unless oopart_inf[:name]
                a.name = "oopart_inf"
            end
            return a }
        hash.[]=(:oopart_inf,lam,false)
    end
            

    unless ierr_inf.is_a? Hash
        # hash.new_index(:ierr_inf) = ierr_inf
        if ierr_inf.is_a? BaseElm
            hash.[]=(:ierr_inf,ierr_inf,true)
        else
            hash.[]=(:ierr_inf,ierr_inf,false)
        end
    else
        # hash.new_index(:ierr_inf)= lambda { a = DataInf_C.new(ierr_inf);a.name = "ierr_inf";return a }
        # hash[:ierr_inf] = lambda { a = DataInf_C.new(ierr_inf);a.name = "ierr_inf";return a }
        lam = lambda {
            a = DataInf_C.new(ierr_inf)
            unless ierr_inf[:name]
                a.name = "ierr_inf"
            end
            return a }
        hash.[]=(:ierr_inf,lam,false)
    end
            

    unless oerr_inf.is_a? Hash
        # hash.new_index(:oerr_inf) = oerr_inf
        if oerr_inf.is_a? BaseElm
            hash.[]=(:oerr_inf,oerr_inf,true)
        else
            hash.[]=(:oerr_inf,oerr_inf,false)
        end
    else
        # hash.new_index(:oerr_inf)= lambda { a = DataInf_C.new(oerr_inf);a.name = "oerr_inf";return a }
        # hash[:oerr_inf] = lambda { a = DataInf_C.new(oerr_inf);a.name = "oerr_inf";return a }
        lam = lambda {
            a = DataInf_C.new(oerr_inf)
            unless oerr_inf[:name]
                a.name = "oerr_inf"
            end
            return a }
        hash.[]=(:oerr_inf,lam,false)
    end
            

    Tdl.module_stack  << lambda {
        hash.each do |k,v|
            if v.is_a? Proc
                hash.[]=(k,v.call,false)
            elsif v.is_a? Array
                unless v.empty?
                    if v[0].is_a? Axi4
                        cm = v[0].copy(name:k,idsize:Math.log2(v.length).ceil+v[0].idsize)
                    else
                        cm = v[0].copy(name:k)
                    end
                    cm.<<(*v)
                    # hash[k] = cm
                    hash.[]=(k,cm)
                else
                    hash.[]=(k,nil,false)
                end
            else
                # hash[k] = v
            end
        end
        hash.check_use("part_data_pair_map")
        DataInf_C.part_data_pair_map(hash)
    }
    return hash
end
inst_simple_video_gen_a2(mode:"1080P@60",dsize:24,enable:"enable",inf:"inf") click to toggle source
# File lib/tdl/axi_stream/bak/simple_video_gen_A2.rb, line 61
def self.inst_simple_video_gen_a2(mode:"1080P@60",dsize:24,enable:"enable",inf:"inf")
    hash = TdlHash.new

    unless mode.is_a? Hash
        # hash.new_index(:mode) = mode
        if mode.is_a? InfElm
            hash.[]=(:mode,mode,true)
        else
            hash.[]=(:mode,mode,false)
        end
    else
        # hash.new_index(:mode)= lambda { a = Parameter.new(mode);a.name = "mode";return a }
        # hash[:mode] = lambda { a = Parameter.new(mode);a.name = "mode";return a }
        hash.[]=(:mode,lambda { a = Parameter.new(mode);a.name = "mode";return a },false)
    end


    unless dsize.is_a? Hash
        # hash.new_index(:dsize) = dsize
        if dsize.is_a? InfElm
            hash.[]=(:dsize,dsize,true)
        else
            hash.[]=(:dsize,dsize,false)
        end
    else
        # hash.new_index(:dsize)= lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        # hash[:dsize] = lambda { a = Parameter.new(dsize);a.name = "dsize";return a }
        hash.[]=(:dsize,lambda { a = Parameter.new(dsize);a.name = "dsize";return a },false)
    end


    unless enable.is_a? Hash
        # hash.new_index(:enable) = enable
        if enable.is_a? InfElm
            hash.[]=(:enable,enable,true)
        else
            hash.[]=(:enable,enable,false)
        end
    else
        # hash.new_index(:enable)= lambda { a = Logic.new(enable);a.name = "enable";return a }
        # hash[:enable] = lambda { a = Logic.new(enable);a.name = "enable";return a }
        hash.[]=(:enable,lambda { a = Logic.new(enable);a.name = "enable";return a },false)
    end


    unless inf.is_a? Hash
        # hash.new_index(:inf) = inf
        if inf.is_a? InfElm
            hash.[]=(:inf,inf,true)
        else
            hash.[]=(:inf,inf,false)
        end
    else
        # hash.new_index(:inf)= lambda { a = VideoInf.new(inf);a.name = "inf";return a }
        # hash[:inf] = lambda { a = VideoInf.new(inf);a.name = "inf";return a }
        hash.[]=(:inf,lambda { a = VideoInf.new(inf);a.name = "inf";return a },false)
    end


    Tdl.module_stack  << lambda {
        hash.each do |k,v|
            if v.is_a? Proc
                hash.[]=(k,v.call,false)
            elsif v.is_a? Array
                unless v.empty?
                    if v[0].is_a? Axi4
                        cm = v[0].copy(name:k,idsize:Math.log2(v.length).ceil+v[0].idsize)
                    else
                        cm = v[0].copy(name:k)
                    end
                    cm.<<(*v)
                    # hash[k] = cm
                    hash.[]=(k,cm)
                else
                    hash.[]=(k,nil,false)
                end
            else
                # hash[k] = v
            end
        end
        hash.check_use("simple_video_gen_a2")
        VideoInf.simple_video_gen_a2(hash)
    }
    return hash
end
inst_stream_crc( crc:"crc", axis_in:"axis_in") click to toggle source
# File lib/tdl/axi_stream/bak/stream_crc_auto.rb, line 66
def Tdl.inst_stream_crc(
    crc:"crc",
    axis_in:"axis_in")
    hash = TdlHash.new
    
    unless crc.is_a? Hash
        hash.case_record(:crc,crc)
    else
        # hash.new_index(:crc)= lambda { a = Logic.new(crc);a.name = "crc";return a }
        # hash[:crc] = lambda { a = Logic.new(crc);a.name = "crc";return a }
        raise TdlError.new('stream_crc Logic crc TdlHash cant include Proc') if crc.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = Logic.new(crc)
            unless crc[:name]
                a.name = "crc"
            end
            return a }
        hash.[]=(:crc,lam,false)
    end
            

    unless axis_in.is_a? Hash
        hash.case_record(:axis_in,axis_in)
    else
        # hash.new_index(:axis_in)= lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        # hash[:axis_in] = lambda { a = AxiStream.new(axis_in);a.name = "axis_in";return a }
        raise TdlError.new('stream_crc AxiStream axis_in TdlHash cant include Proc') if axis_in.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = AxiStream.new(axis_in)
            unless axis_in[:name]
                a.name = "axis_in"
            end
            return a }
        hash.[]=(:axis_in,lam,false)
    end
            

    hash.push_to_module_stack(AxiStream,:stream_crc)
    hash.open_error = true
    return hash
end
inst_udp_server_bfm(tx_udp_inf:"tx_udp_inf", rx_udp_inf:"rx_udp_inf") click to toggle source
# File lib/tdl/axi_stream/bak/udp_server_bfm_auto.rb, line 61
def Tdl.inst_udp_server_bfm(tx_udp_inf:"tx_udp_inf",
    rx_udp_inf:"rx_udp_inf")
    hash = TdlHash.new
    
    unless tx_udp_inf.is_a? Hash
        # hash.new_index(:tx_udp_inf) = tx_udp_inf
        if tx_udp_inf.is_a? BaseElm
            hash.[]=(:tx_udp_inf,tx_udp_inf,true)
        else
            hash.[]=(:tx_udp_inf,tx_udp_inf,false)
        end
    else
        # hash.new_index(:tx_udp_inf)= lambda { a = AxiStream.new(tx_udp_inf);a.name = "tx_udp_inf";return a }
        # hash[:tx_udp_inf] = lambda { a = AxiStream.new(tx_udp_inf);a.name = "tx_udp_inf";return a }
        lam = lambda {
            a = AxiStream.new(tx_udp_inf)
            unless tx_udp_inf[:name]
                a.name = "tx_udp_inf"
            end
            return a }
        hash.[]=(:tx_udp_inf,lam,false)
    end
            

    unless rx_udp_inf.is_a? Hash
        # hash.new_index(:rx_udp_inf) = rx_udp_inf
        if rx_udp_inf.is_a? BaseElm
            hash.[]=(:rx_udp_inf,rx_udp_inf,true)
        else
            hash.[]=(:rx_udp_inf,rx_udp_inf,false)
        end
    else
        # hash.new_index(:rx_udp_inf)= lambda { a = AxiStream.new(rx_udp_inf);a.name = "rx_udp_inf";return a }
        # hash[:rx_udp_inf] = lambda { a = AxiStream.new(rx_udp_inf);a.name = "rx_udp_inf";return a }
        lam = lambda {
            a = AxiStream.new(rx_udp_inf)
            unless rx_udp_inf[:name]
                a.name = "rx_udp_inf"
            end
            return a }
        hash.[]=(:rx_udp_inf,lam,false)
    end
            

    Tdl.module_stack  << lambda {
        hash.each do |k,v|
            if v.is_a? Proc
                hash.[]=(k,v.call,false)
            elsif v.is_a? Array
                unless v.empty?
                    if v[0].is_a? Axi4
                        cm = v[0].copy(name:k,idsize:Math.log2(v.length).ceil+v[0].idsize)
                    else
                        cm = v[0].copy(name:k)
                    end
                    cm.<<(*v)
                    # hash[k] = cm
                    hash.[]=(k,cm)
                else
                    hash.[]=(k,nil,false)
                end
            else
                # hash[k] = v
            end
        end
        hash.check_use("udp_server_bfm")
        AxiStream.udp_server_bfm(hash)
    }
    return hash
end
inst_udp_server_ctrl_bfm(tx_udp_inf:"tx_udp_inf", rx_udp_inf:"rx_udp_inf") click to toggle source
# File lib/tdl/axi_stream/bak/udp_server_ctrl_bfm_auto.rb, line 61
def Tdl.inst_udp_server_ctrl_bfm(tx_udp_inf:"tx_udp_inf",
    rx_udp_inf:"rx_udp_inf")
    hash = TdlHash.new
    
    unless tx_udp_inf.is_a? Hash
        # hash.new_index(:tx_udp_inf) = tx_udp_inf
        if tx_udp_inf.is_a? BaseElm
            hash.[]=(:tx_udp_inf,tx_udp_inf,true)
        else
            hash.[]=(:tx_udp_inf,tx_udp_inf,false)
        end
    else
        # hash.new_index(:tx_udp_inf)= lambda { a = AxiStream.new(tx_udp_inf);a.name = "tx_udp_inf";return a }
        # hash[:tx_udp_inf] = lambda { a = AxiStream.new(tx_udp_inf);a.name = "tx_udp_inf";return a }
        lam = lambda {
            a = AxiStream.new(tx_udp_inf)
            unless tx_udp_inf[:name]
                a.name = "tx_udp_inf"
            end
            return a }
        hash.[]=(:tx_udp_inf,lam,false)
    end
            

    unless rx_udp_inf.is_a? Hash
        # hash.new_index(:rx_udp_inf) = rx_udp_inf
        if rx_udp_inf.is_a? BaseElm
            hash.[]=(:rx_udp_inf,rx_udp_inf,true)
        else
            hash.[]=(:rx_udp_inf,rx_udp_inf,false)
        end
    else
        # hash.new_index(:rx_udp_inf)= lambda { a = AxiStream.new(rx_udp_inf);a.name = "rx_udp_inf";return a }
        # hash[:rx_udp_inf] = lambda { a = AxiStream.new(rx_udp_inf);a.name = "rx_udp_inf";return a }
        lam = lambda {
            a = AxiStream.new(rx_udp_inf)
            unless rx_udp_inf[:name]
                a.name = "rx_udp_inf"
            end
            return a }
        hash.[]=(:rx_udp_inf,lam,false)
    end
            

    Tdl.module_stack  << lambda {
        hash.each do |k,v|
            if v.is_a? Proc
                hash.[]=(k,v.call,false)
            elsif v.is_a? Array
                unless v.empty?
                    if v[0].is_a? Axi4
                        cm = v[0].copy(name:k,idsize:Math.log2(v.length).ceil+v[0].idsize)
                    else
                        cm = v[0].copy(name:k)
                    end
                    cm.<<(*v)
                    # hash[k] = cm
                    hash.[]=(k,cm)
                else
                    hash.[]=(k,nil,false)
                end
            else
                # hash[k] = v
            end
        end
        hash.check_use("udp_server_ctrl_bfm")
        AxiStream.udp_server_ctrl_bfm(hash)
    }
    return hash
end
inst_video_to_vdma(mode:"LINE",base_addr:"base_addr",video_inf:"video_inf",axi_master:"axi_master") click to toggle source
# File lib/tdl/axi_stream/bak/video_to_VDMA.rb, line 68
def self.inst_video_to_vdma(mode:"LINE",base_addr:"base_addr",video_inf:"video_inf",axi_master:"axi_master")
    hash = TdlHash.new

    unless mode.is_a? Hash
        # hash.new_index(:mode) = mode
        if mode.is_a? InfElm
            hash.[]=(:mode,mode,true)
        else
            hash.[]=(:mode,mode,false)
        end
    else
        # hash.new_index(:mode)= lambda { a = Parameter.new(mode);a.name = "mode";return a }
        # hash[:mode] = lambda { a = Parameter.new(mode);a.name = "mode";return a }
        hash.[]=(:mode,lambda { a = Parameter.new(mode);a.name = "mode";return a },false)
    end


    unless base_addr.is_a? Hash
        # hash.new_index(:base_addr) = base_addr
        if base_addr.is_a? InfElm
            hash.[]=(:base_addr,base_addr,true)
        else
            hash.[]=(:base_addr,base_addr,false)
        end
    else
        # hash.new_index(:base_addr)= lambda { a = Logic.new(base_addr);a.name = "base_addr";return a }
        # hash[:base_addr] = lambda { a = Logic.new(base_addr);a.name = "base_addr";return a }
        hash.[]=(:base_addr,lambda { a = Logic.new(base_addr);a.name = "base_addr";return a },false)
    end


    unless video_inf.is_a? Hash
        # hash.new_index(:video_inf) = video_inf
        if video_inf.is_a? InfElm
            hash.[]=(:video_inf,video_inf,true)
        else
            hash.[]=(:video_inf,video_inf,false)
        end
    else
        # hash.new_index(:video_inf)= lambda { a = VideoInf.new(video_inf);a.name = "video_inf";return a }
        # hash[:video_inf] = lambda { a = VideoInf.new(video_inf);a.name = "video_inf";return a }
        hash.[]=(:video_inf,lambda { a = VideoInf.new(video_inf);a.name = "video_inf";return a },false)
    end


    unless axi_master.is_a? Hash
        # hash.new_index(:axi_master) = axi_master
        if axi_master.is_a? InfElm
            hash.[]=(:axi_master,axi_master,true)
        else
            hash.[]=(:axi_master,axi_master,false)
        end
    else
        # hash.new_index(:axi_master)= lambda { a = Axi4.new(axi_master);a.name = "axi_master";return a }
        # hash[:axi_master] = lambda { a = Axi4.new(axi_master);a.name = "axi_master";return a }
        hash.[]=(:axi_master,lambda { a = Axi4.new(axi_master);a.name = "axi_master";return a },false)
    end


    Tdl.module_stack  << lambda {
        hash.each do |k,v|
            if v.is_a? Proc
                hash.[]=(k,v.call,false)
            elsif v.is_a? Array
                unless v.empty?
                    if v[0].is_a? Axi4
                        cm = v[0].copy(name:k,idsize:Math.log2(v.length).ceil+v[0].idsize)
                    else
                        cm = v[0].copy(name:k)
                    end
                    cm.<<(*v)
                    # hash[k] = cm
                    hash.[]=(k,cm)
                else
                    hash.[]=(k,nil,false)
                end
            else
                # hash[k] = v
            end
        end
        hash.check_use("video_to_vdma")
        Axi4.video_to_vdma(hash)
    }
    return hash
end
log_array(info,ay) click to toggle source

log puts

# File lib/tdl/tdl.rb, line 244
def self.log_array(info,ay)
    if ay.any?
        Tdl.Puts pagination(info)
        ay.each_index do |index|
            puts "[#{index}] : #{ay[index].to_s}"
        end
    end
end
puts_log() click to toggle source
# File lib/tdl/tdl.rb, line 253
def self.puts_log
    return unless @@puts_enable
    if @@build_tdlmodule_collect.empty? && @@build_sdlmodule_collect.empty? && @@warning_collect.empty?
        return
    end
    ##
    self.log_array("LOG FOR GEN TDLMOUDLE",@@build_tdlmodule_collect)
    self.log_array("LOG FOR GEN SDLMOUDLE",@@build_sdlmodule_collect)
    self.log_array("LOG OF WARNING",@@warning_collect)
    # puts(page(tag: "SUMMARY" ,body: "RUN @ TIME : #{Time.now}"))
    puts(pagination("TEST POINT")) if TopModule.current
    # puts TdlTestPoint.echo_list
    # puts(pagination("SIM TEST"))
    # puts TdlSimTest::TdlBaseTestUnit.echo_prj_test_list
    puts SdlModule.echo_tracked_by_dve if TopModule.current && TopModule.sim
    puts(pagination("TEST UNIT")) if TopModule.current
    # puts TopModule.current.test_unit.echo_units if TopModule.current
    puts TestUnitModule.echo_be_instanced_by_sim if TopModule.current
    puts(pagination("SUMMARY"))
    puts "#{TopModule.sim ? 'SIM' : 'SYNTH'} RUN SPEND #{Time.now - $__start_time__} sec @ TIME : #{Time.now}"

end
warning(argv,filename=nil,line=nil) click to toggle source
# File lib/tdl/tdl.rb, line 230
def self.warning(argv,filename=nil,line=nil)
    # if line
    #     argv = "\n    LINE[#{line}]\n        >>>#{argv}"
    # end

    if filename
        argv = "\n    [FILE] #{filename}(#{line})\n    >>>>#{argv}"
    end

    @@warning_collect << argv
end