Class: Tdl

Inherits:
Object
  • Object
show all
Defined in:
lib/tdl/tdl.rb,
lib/tdl/tdl.rb,
lib/tdl/tdl.rb,
lib/tdl/tdl.rb,
lib/tdl/axi4/bak/axi4_pipe_auto.rb,
lib/tdl/sdlmodule/sdlmodule_draw.rb,
lib/tdl/axi4/bak/axi4_direct_auto.rb,
lib/tdl/data_inf/bak/_data_mirrors.rb,
lib/tdl/data_inf/bak/data_bind_auto.rb,
lib/tdl/axi_stream/bak/_axis_mirrors.rb,
lib/tdl/axi_stream/bak/video_to_VDMA.rb,
lib/tdl/data_inf/bak/data_valve_auto.rb,
lib/tdl/axi4/bak/axis_to_axi4_wr_auto.rb,
lib/tdl/axi4/bak/idata_pool_axi4_auto.rb,
lib/tdl/axi4/bak/odata_pool_axi4_auto.rb,
lib/tdl/axi_stream/bak/axis_append_A1.rb,
lib/tdl/data_inf/bak/common_fifo_auto.rb,
lib/tdl/axi4/bak/axi4_direct_verb_auto.rb,
lib/tdl/axi4/bak/axi4_packet_fifo_auto.rb,
lib/tdl/axi_stream/bak/axis_valve_auto.rb,
lib/tdl/axi_stream/bak/stream_crc_auto.rb,
lib/tdl/data_inf/bak/data_mirrors_auto.rb,
lib/tdl/axi_stream/bak/axis_append_auto.rb,
lib/tdl/axi_stream/bak/axis_direct_auto.rb,
lib/tdl/axi_stream/bak/axis_filter_auto.rb,
lib/tdl/data_inf/bak/data_c_direct_auto.rb,
lib/tdl/axi4/bak/odata_pool_axi4_A1_auto.rb,
lib/tdl/axi_stream/bak/axis_mirrors_auto.rb,
lib/tdl/axi_stream/bak/axi_streams_scaler.rb,
lib/tdl/axi_stream/bak/video_to_VDMA_auto.rb,
lib/tdl/data_inf/bak/data_uncompress_auto.rb,
lib/tdl/axi_stream/bak/axis_append_A1_auto.rb,
lib/tdl/axi_stream/bak/data_to_axis_inf_A1.rb,
lib/tdl/axi_stream/bak/simple_video_gen_A2.rb,
lib/tdl/axi_stream/bak/udp_server_bfm_auto.rb,
lib/tdl/data_inf/bak/data_c_tmp_cache_auto.rb,
lib/tdl/axi_stream/bak/axis_ram_buffer_auto.rb,
lib/tdl/axi_stream/bak/axis_to_axi4_wr_auto.rb,
lib/tdl/axi_stream/bak/axis_uncompress_auto.rb,
lib/tdl/axi_stream/bak/gen_origin_axis_auto.rb,
lib/tdl/axi_stream/bak/gen_simple_axis_auto.rb,
lib/tdl/axi_stream/bak/idata_pool_axi4_auto.rb,
lib/tdl/axi4/bak/axi4_long_to_axi4_wide_auto.rb,
lib/tdl/axi_stream/bak/axi_stream_cache_auto.rb,
lib/tdl/axi_stream/bak/axis_length_fill_auto.rb,
lib/tdl/axi_stream/bak/axis_slaver_pipe_auto.rb,
lib/tdl/axi_stream/bak/axis_to_data_inf_auto.rb,
lib/tdl/axi_stream/bak/check_stream_crc_auto.rb,
lib/tdl/axi_stream/bak/data_to_axis_inf_auto.rb,
lib/tdl/axi_stream/bak/dynamic_port_cfg_auto.rb,
lib/tdl/data_inf/bak/part_data_pair_map_auto.rb,
lib/tdl/axi4/bak/axi4_combin_wr_rd_batch_auto.rb,
lib/tdl/axi_stream/bak/axis_connect_pipe_auto.rb,
lib/tdl/axi_stream/bak/axis_length_split_auto.rb,
lib/tdl/axi_stream/bak/axis_master_empty_auto.rb,
lib/tdl/axi_stream/bak/axis_slaver_empty_auto.rb,
lib/tdl/axi_stream/bak/axis_width_combin_auto.rb,
lib/tdl/axi_stream/bak/axis_wrapper_oled_auto.rb,
lib/tdl/axi_stream/bak/dynnamic_addr_cfg_auto.rb,
lib/tdl/axi_stream/bak/axi_streams_combin_auto.rb,
lib/tdl/axi_stream/bak/axi_streams_scaler_auto.rb,
lib/tdl/axi_stream/bak/axis_width_convert_auto.rb,
lib/tdl/axi_stream/bak/part_data_pair_map_auto.rb,
lib/tdl/data_inf/bak/data_c_direct_mirror_auto.rb,
lib/tdl/data_inf/bak/data_condition_valve_auto.rb,
lib/tdl/data_inf/bak/data_mirrors_verb.sv_auto.rb,
lib/tdl/data_inf/bak/datainf_master_empty_auto.rb,
lib/tdl/data_inf/bak/datainf_slaver_empty_auto.rb,
lib/tdl/axi4/bak/axi4_long_to_axi4_wide_A1_auto.rb,
lib/tdl/axi_lite/bak/axi_lite_master_empty_auto.rb,
lib/tdl/axi_lite/bak/axi_lite_slaver_empty_auto.rb,
lib/tdl/axi_stream/bak/axi_stream_cache_B1_auto.rb,
lib/tdl/axi_stream/bak/axis_slaver_pipe_A1_auto.rb,
lib/tdl/axi_stream/bak/axis_width_destruct_auto.rb,
lib/tdl/axi_stream/bak/data_to_axis_inf_A1_auto.rb,
lib/tdl/axi_stream/bak/gen_big_field_table_auto.rb,
lib/tdl/axi_stream/bak/simple_video_gen_A2_auto.rb,
lib/tdl/axi_stream/bak/udp_server_ctrl_bfm_auto.rb,
lib/tdl/data_inf/bak/data_condition_mirror_auto.rb,
lib/tdl/data_inf/bak/data_connect_pipe_inf_auto.rb,
lib/tdl/axi_stream/bak/axi_stream_long_fifo_auto.rb,
lib/tdl/axi_stream/bak/axi_stream_partition_auto.rb,
lib/tdl/axi_stream/bak/axis_valve_with_pipe_auto.rb,
lib/tdl/axi_stream/bak/datainf_master_empty_auto.rb,
lib/tdl/axi_stream/bak/datainf_slaver_empty_auto.rb,
lib/tdl/data_inf/bak/datainf_c_master_empty_auto.rb,
lib/tdl/data_inf/bak/datainf_c_slaver_empty_auto.rb,
lib/tdl/data_inf/bak/independent_clock_fifo_auto.rb,
lib/tdl/axi4/bak/axi4_long_to_axi4_wide_verb_auto.rb,
lib/tdl/axi_lite/bak/jtag_to_axilite_wrapper_auto.rb,
lib/tdl/axi_stream/bak/axi_stream_cache_verb_auto.rb,
lib/tdl/axi_stream/bak/axis_combin_with_fifo_auto.rb,
lib/tdl/axi_stream/bak/parse_big_field_table_auto.rb,
lib/tdl/axi_stream/bak/axi_stream_cache_35bit_auto.rb,
lib/tdl/axi_stream/bak/axi_stream_packet_fifo_auto.rb,
lib/tdl/axi_stream/bak/datainf_c_master_empty_auto.rb,
lib/tdl/axi_stream/bak/datainf_c_slaver_empty_auto.rb,
lib/tdl/axi_stream/bak/axi_stream_cache_mirror_auto.rb,
lib/tdl/axi_stream/bak/axi_stream_partition_A1_auto.rb,
lib/tdl/axi_stream/bak/axis_connect_pipe_A1.sv_auto.rb,
lib/tdl/data_inf/bak/data_inf_c_pipe_condition_auto.rb,
lib/tdl/axi_stream/bak/__axi_stream_interconnect_S2M.rb,
lib/tdl/axi_stream/bak/parse_big_field_table_A1_auto.rb,
lib/tdl/axi_stream/bak/parse_big_field_table_A2_auto.rb,
lib/tdl/axi4/bak/__axi4_wr_auxiliary_gen_without_resp.rb,
lib/tdl/axi_stream/bak/axis_pkt_fifo_filter_keep_auto.rb,
lib/tdl/axi_stream/bak/axi_stream_interconnect_S2M_auto.rb,
lib/tdl/axi_stream/bak/axis_connect_pipe_with_info_auto.rb,
lib/tdl/axi_stream/bak/axis_length_split_with_addr_auto.rb,
lib/tdl/axi4/bak/axi4_wr_auxiliary_gen_without_resp_auto.rb,
lib/tdl/axi_stream/bak/axi4_to_native_for_ddr_ip_verb_auto.rb,
lib/tdl/axi_stream/bak/axi_stream_packet_fifo_with_info_auto.rb,
lib/tdl/axi_stream/bak/axi_stream_cache_72_95bit_with_keep_auto.rb,
lib/tdl/axi_stream/bak/axi_stream_interconnect_S2M_with_keep.sv_auto.rb

Overview

read sdlmodule head

Constant Summary collapse

@@Axi4Path = 
'E:\work\AXI'
@@puts_enable = 

      
        
@@build_tdlmodule_collect =
          
        

        
[]

      
        
@@build_sdlmodule_collect =
          
        

        
[]

      
        
@@warning_collect =
          
        

        
[]

      
        
@@__head_logo__ =
          
        

        
nil

      
    

  







  
    

      Class Method Summary
      collapse
    


    
  



  

    
Class Method Details


    
      

  

  
    .add_to_all_file_paths(a, b)  ⇒ Object 
  

  

  




  

    

add file paths



  





  



  

    
      


173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188

    		
    
      
# 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  ⇒ Object 
  

  

  




  

    
      


190
191
192

    		
    
      
# File 'lib/tdl/tdl.rb', line 190

def self.all_file_paths
    @@all_file_paths ||= Hash.new
end

    		
  





    
      

  

  
    .Axi4Path  ⇒ Object 
  

  

  




  

    
      


152
153
154

    		
    
      
# File 'lib/tdl/tdl.rb', line 152

def self.Axi4Path
    @@Axi4Path
end

    		
  





    
      

  

  
    .Axi4Path=(a)  ⇒ Object 
  

  

  




  

    
      


156
157
158
159

    		
    
      
# 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)  ⇒ Object 
  

  

  




  

    
      


225
226
227
228

    		
    
      
# 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)  ⇒ Object 
  

  

  




  

    
      


220
221
222
223

    		
    
      
# File 'lib/tdl/tdl.rb', line 220

def self.Build_TdlModule_Puts(args)
    return unless @@puts_enable
    @@build_tdlmodule_collect << args
end

    		
  





    
      

  

  
    .comment(c = "-", info = "_____")  ⇒ Object 
  

  

  




  

    
      


144
145
146

    		
    
      
# File 'lib/tdl/tdl.rb', line 144

def self.comment(c="-",info="_____")
    "\n//#{c*4}>> #{info} <<#{c*40}\n"
end

    		
  





    
      

  

  
    .head_logo  ⇒ Object 
  

  

  




  

    
      


4
5
6

    		
    
      
# File 'lib/tdl/sdlmodule/sdlmodule_draw.rb', line 4

def self. 
    @@__head_logo__
end

    		
  





    
      

  

  
    .head_logo=(a)  ⇒ Object 
  

  

  




  

    
      


8
9
10
11

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

    		
    
      
# 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, num: 8, mode: "CDS_MODE", condition_data: "condition_data", axis_in: "axis_in", axis_mirror: "axis_mirror")  ⇒ Object 
  

  

  




  

    
      


115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

    		
    
      
# 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, num: 8, mode: "CDS_MODE", condition_data: "condition_data", data_in: "data_in", data_mirror: "data_mirror")  ⇒ Object 
  

  

  




  

    
      


118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

    		
    
      
# File 'lib/tdl/data_inf/bak/datainf_c_master_empty_auto.rb', line 71

def Tdl.inst_datainf_c_master_empty(
    master:"master")
    hash = TdlHash.new
    
    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('datainf_c_master_empty 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,:datainf_c_master_empty)
    hash.open_error = true
    return hash
end

    		
  





    
      

  

  
    .inst_datainf_c_slaver_empty(slaver: "slaver")  ⇒ Object 
  

  

  




  

    
      


64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

    		
    
      
# File 'lib/tdl/data_inf/bak/datainf_c_slaver_empty_auto.rb', line 64

def Tdl.inst_datainf_c_slaver_empty(
    slaver:"slaver")
    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('datainf_c_slaver_empty 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
            

    hash.push_to_module_stack(DataInf_C,:datainf_c_slaver_empty)
    hash.open_error = true
    return hash
end

    		
  





    
      

  

  
    .inst_datainf_master_empty(master: "master")  ⇒ Object 
  

  

  




  

    
      


71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

    		
    
      
# File 'lib/tdl/data_inf/bak/datainf_master_empty_auto.rb', line 71

def Tdl.inst_datainf_master_empty(
    master:"master")
    hash = TdlHash.new
    
    unless master.is_a? Hash
        hash.case_record(:master,master)
    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 }
        raise TdlError.new('datainf_master_empty DataInf master TdlHash cant include Proc') if master.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf.new(master)
            unless master[:name]
                a.name = "master"
            end
            return a }
        hash.[]=(:master,lam,false)
    end
            

    hash.push_to_module_stack(DataInf,:datainf_master_empty)
    hash.open_error = true
    return hash
end

    		
  





    
      

  

  
    .inst_datainf_slaver_empty(slaver: "slaver")  ⇒ Object 
  

  

  




  

    
      


64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

    		
    
      
# File 'lib/tdl/data_inf/bak/datainf_slaver_empty_auto.rb', line 64

def Tdl.inst_datainf_slaver_empty(
    slaver:"slaver")
    hash = TdlHash.new
    
    unless slaver.is_a? Hash
        hash.case_record(:slaver,slaver)
    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 }
        raise TdlError.new('datainf_slaver_empty DataInf slaver TdlHash cant include Proc') if slaver.select{ |k,v| v.is_a? Proc }.any?
        lam = lambda {
            a = DataInf.new(slaver)
            unless slaver[:name]
                a.name = "slaver"
            end
            return a }
        hash.[]=(:slaver,lam,false)
    end
            

    hash.push_to_module_stack(DataInf,:datainf_slaver_empty)
    hash.open_error = true
    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")  ⇒ Object 
  

  

  




  

    
      


71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305

    		
    
      
# File 'lib/tdl/data_inf/bak/part_data_pair_map_auto.rb', line 95

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.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('part_data_pair_map 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 isize.is_a? Hash
        hash.case_record(:isize,isize)
    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 }
        raise TdlError.new('part_data_pair_map Parameter isize TdlHash cant include Proc') if isize.select{ |k,v| v.is_a? Proc }.any?
        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.case_record(:osize,osize)
    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 }
        raise TdlError.new('part_data_pair_map Parameter osize TdlHash cant include Proc') if osize.select{ |k,v| v.is_a? Proc }.any?
        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.case_record(:write_inf,write_inf)
    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 }
        raise TdlError.new('part_data_pair_map DataInf_C write_inf TdlHash cant include Proc') if write_inf.select{ |k,v| v.is_a? Proc }.any?
        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.case_record(:ipart_inf,ipart_inf)
    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 }
        raise TdlError.new('part_data_pair_map DataInf_C ipart_inf TdlHash cant include Proc') if ipart_inf.select{ |k,v| v.is_a? Proc }.any?
        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.case_record(:opart_inf,opart_inf)
    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 }
        raise TdlError.new('part_data_pair_map DataInf_C opart_inf TdlHash cant include Proc') if opart_inf.select{ |k,v| v.is_a? Proc }.any?
        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.case_record(:idel_inf,idel_inf)
    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 }
        raise TdlError.new('part_data_pair_map DataInf_C idel_inf TdlHash cant include Proc') if idel_inf.select{ |k,v| v.is_a? Proc }.any?
        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.case_record(:odel_inf,odel_inf)
    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 }
        raise TdlError.new('part_data_pair_map DataInf_C odel_inf TdlHash cant include Proc') if odel_inf.select{ |k,v| v.is_a? Proc }.any?
        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.case_record(:oipart_inf,oipart_inf)
    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 }
        raise TdlError.new('part_data_pair_map DataInf_C oipart_inf TdlHash cant include Proc') if oipart_inf.select{ |k,v| v.is_a? Proc }.any?
        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.case_record(:oopart_inf,oopart_inf)
    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 }
        raise TdlError.new('part_data_pair_map DataInf_C oopart_inf TdlHash cant include Proc') if oopart_inf.select{ |k,v| v.is_a? Proc }.any?
        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.case_record(:ierr_inf,ierr_inf)
    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 }
        raise TdlError.new('part_data_pair_map DataInf_C ierr_inf TdlHash cant include Proc') if ierr_inf.select{ |k,v| v.is_a? Proc }.any?
        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.case_record(:oerr_inf,oerr_inf)
    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 }
        raise TdlError.new('part_data_pair_map DataInf_C oerr_inf TdlHash cant include Proc') if oerr_inf.select{ |k,v| v.is_a? Proc }.any?
        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
            

    hash.push_to_module_stack(DataInf_C,:part_data_pair_map)
    hash.open_error = true
    return hash
end

    		
  





    
      

  

  
    .inst_simple_video_gen_a2(mode: "1080P@60", dsize: 24, enable: "enable", inf: "inf")  ⇒ Object 
  

  

  




  

    
      


61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

    		
    
      
# 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")  ⇒ Object 
  

  

  




  

    
      


68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

    		
    
      
# 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)  ⇒ Object 
  

  

  




  

    

log puts



  





  



  

    
      


244
245
246
247
248
249
250
251

    		
    
      
# 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(*args)  ⇒ Object 
  

  

  




  

    
      


216
217
218

    		
    
      
# File 'lib/tdl/tdl.rb', line 216

def self.Puts(*args)
    puts args if @@puts_enable
end

    		
  





    
      

  

  
    .puts_log  ⇒ Object 
  

  

  




  

    
      


253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274

    		
    
      
# 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

    		
  





    
      

  

  
    .PutsEnable  ⇒ Object 
  

  

  




  

    
      


212
213
214

    		
    
      
# File 'lib/tdl/tdl.rb', line 212

def self.PutsEnable
    @@puts_enable
end

    		
  





    
      

  

  
    .PutsEnable=(a)  ⇒ Object 
  

  

  




  

    
      


208
209
210

    		
    
      
# File 'lib/tdl/tdl.rb', line 208

def self.PutsEnable=(a)
    @@puts_enable = a
end

    		
  





    
      

  

  
    .warning(argv, filename = nil, line = nil)  ⇒ Object 
  

  

  




  

    
      


230
231
232
233
234
235
236
237
238
239
240

    		
    
      
# 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