axi_tdl 0.0.19 → 0.1.7

data/lib/tdl/axi4/axi4_interconnect_verb.rb

@@ -66,7 +66,34 @@ class Axi4
             # next unless e.is_a? Axi4
             if e.is_a? Axi4
                 e.band_params_from(self)
-                @interconnect_up_streams << e
+                
+                ## e is a Vector 
+                if e.dimension[0].is_a?(Integer) && e.dimension[0] > 1
+                    # require_hdl 'axi4_direct_B1.sv'
+                    require_hdl 'axi4_direct_verc.sv'
+
+                    e.dimension[0].times do |xi|
+                        _ne = e.copy(name: "#{e.inst_name}_toM_#{xi}")
+                        # _ne << e[xi]
+                        # belong_to_module.Instance('axi4_direct_B1',"axi4_direc_#{e.inst_name}_toM_#{xi}") do |h|
+                        #     # h.param.MODE    mode_str    #//ONLY_READ to BOTH,ONLY_WRITE to BOTH,BOTH to BOTH,BOTH to ONLY_READ,BOTH to ONLY_WRITE
+                        #     h.slaver_inf        e[xi]
+                        #     h.master_inf        _ne
+                        # end
+
+                        belong_to_module.Instance('axi4_direct_verc',"axi4_direc_#{e.inst_name}_toM_#{xi}") do |h|
+                            h.param.MODE            "#{_ne.mode}_to_#{_ne.mode}"    # //ONLY_READ to BOTH,ONLY_WRITE to BOTH,BOTH to BOTH,BOTH to ONLY_READ,BOTH to ONLY_WRITE
+                            h.param.SLAVER_MODE     _ne.mode    #    //
+                            h.param.MASTER_MODE     _ne.mode    #    //
+                            h.slaver_inf        e[xi]
+                            h.master_inf        _ne
+                        end
+                
+                        @interconnect_up_streams << _ne 
+                    end    
+                else
+                    @interconnect_up_streams << e
+                end
             else
                 raise TdlError.new("When use `<<` for axi4's M2S ,argvs must be axi4 too.\nOtherwise use `naxi4_mix_interconnect_M2S` directly")
             end
@@ -218,11 +245,20 @@ class Axi4
                 else
                     mode_str = "ONLY_READ_to_BOTH"
                 end
-                require_hdl 'axi4_direct_B1.sv'
-                # Axi4.axi4_direct_a1(mode:mode_str,slaver:lo,master:"#{sub_name}[#{index}]",belong_to_module:belong_to_module)
-                belong_to_module.Instance('axi4_direct_B1',"axi4_direct_a1_long_to_wide_#{sub_name}_#{globle_random_name_flag()}") do |h|
-                    # h.param.MODE    mode_str    #//ONLY_READ to BOTH,ONLY_WRITE to BOTH,BOTH to BOTH,BOTH to ONLY_READ,BOTH to ONLY_WRITE
-                    h.slaver_inf        lo
+                # require_hdl 'axi4_direct_B1.sv'
+                # # Axi4.axi4_direct_a1(mode:mode_str,slaver:lo,master:"#{sub_name}[#{index}]",belong_to_module:belong_to_module)
+                # belong_to_module.Instance('axi4_direct_B1',"axi4_direct_a1_long_to_wide_#{sub_name}_#{globle_random_name_flag()}") do |h|
+                #     # h.param.MODE    mode_str    #//ONLY_READ to BOTH,ONLY_WRITE to BOTH,BOTH to BOTH,BOTH to ONLY_READ,BOTH to ONLY_WRITE
+                #     h.slaver_inf        lo
+                #     h.master_inf        "#{sub_name}[#{index}]".to_nq
+                # end
+
+                require_hdl 'axi4_direct_verc.sv'
+                belong_to_module.Instance('axi4_direct_verc',"axi4_direct_a1_long_to_wide_#{sub_name}_#{globle_random_name_flag()}") do |h|
+                    h.param.MODE            mode_str    # //ONLY_READ to BOTH,ONLY_WRITE to BOTH,BOTH to BOTH,BOTH to ONLY_READ,BOTH to ONLY_WRITE
+                    h.param.SLAVER_MODE     (wr_lg ? "ONLY_WRITE" : "ONLY_READ")    #    //
+                    h.param.MASTER_MODE     "BOTH"    #    //
+                    h.slaver_inf        (lo.respond_to?(:dimension) && lo.dimension[0]==1 && lo[0])  || lo
                     h.master_inf        "#{sub_name}[#{index}]".to_nq
                 end
 
@@ -252,10 +288,11 @@ class Axi4
         @_long_slim_to_wide.each do |e|
             mode_str = e.mode + "_to_BOTH"
             # Axi4.axi4_direct_a1(mode:mode_str,slaver:e,master:"#{sub_name}[#{index}]",belong_to_module:belong_to_module)
+            require_hdl 'axi4_direct_B1.sv'
             belong_to_module.Instance('axi4_direct_B1',"axi4_direct_a1_inst_long_to_wide_#{sub_name}") do |h|
                 # h.param.MODE    mode_str    #//ONLY_READ to BOTH,ONLY_WRITE to BOTH,BOTH to BOTH,BOTH to ONLY_READ,BOTH to ONLY_WRITE
-                h.slaver        e
-                h.master        "#{sub_name}[#{index}]".to_nq
+                h.slaver_inf        e
+                h.master_inf        "#{sub_name}[#{index}]".to_nq
             end
             index = index + 1
         end
@@ -311,8 +348,8 @@ class Axi4
 "\naxi4_direct_B1 /* #(
     .MODE       (\"#{_str}\")    //ONLY_READ to BOTH,ONLY_WRITE to BOTH,BOTH to BOTH,BOTH to ONLY_READ,BOTH to ONLY_WRITE
 )*/ iterconnect_direct_A1_#{name}_instMM(
-/* axi_inf.slaver */  .slaver   (sub_axi_#{name}_inf[0]),
-/* axi_inf.master */  .master   (#{name})
+/* axi_inf.slaver */  .slaver_inf   (sub_axi_#{name}_inf[0]),
+/* axi_inf.master */  .master_inf   (#{name})
 );\n"
         end
 

data/lib/tdl/class_hdl/hdl_always_comb.rb

@@ -7,6 +7,9 @@ module ClassHDL
         def initialize(belong_to_module)
             @opertor_chains = []
             @belong_to_module = belong_to_module
+            unless @belong_to_module
+                raise TdlError.new("HDLAlwaysCombBlock must have belong_to_module")
+            end
         end
 
         def instance
@@ -17,7 +20,7 @@ module ClassHDL
                     str.push op.instance(:assign).gsub(/^./){ |m| "    #{m}"}
                 else 
                     unless op.slaver
-                        rel_str = ClassHDL.compact_op_ch(op.instance(:assign))
+                        rel_str = ClassHDL.compact_op_ch(op.instance(:assign, @belong_to_module))
                         str.push "    #{rel_str};"
                     end
                 end

data/lib/tdl/class_hdl/hdl_always_ff.rb

@@ -63,7 +63,7 @@ module ClassHDL
                     str.push op.instance(:always_ff).gsub(/^./){ |m| "    #{m}"}
                 else 
                     unless op.slaver
-                        rel_str = ClassHDL.compact_op_ch(op.instance(:always_ff))
+                        rel_str = ClassHDL.compact_op_ch(op.instance(:always_ff, belong_to_module))
                         str.push "    #{rel_str};"
                     end
                 end
@@ -143,7 +143,7 @@ module ClassHDL
                     str.push op.instance(:assign).gsub(/^./){ |m| "    #{m}"}
                 else 
                     unless op.slaver
-                        rel_str = ClassHDL.compact_op_ch(op.instance(:assign))
+                        rel_str = ClassHDL.compact_op_ch(op.instance(:assign, belong_to_module))
                         str.push "    #{rel_str};"
                     end
                 end

data/lib/tdl/class_hdl/hdl_assign.rb

@@ -8,14 +8,20 @@ module ClassHDL
         def initialize(belong_to_module)
             @opertor_chains = []
             @belong_to_module = belong_to_module
+            unless @belong_to_module 
+                raise TdlError.new("HDLAssignBlock must have belong_to_module")
+            end
         end
 
         def instance
+            unless @belong_to_module.is_a?(SdlModule) 
+                raise TdlError.new("HDLAssignBlock must have belong_to_module")
+            end
             str = []
             opertor_chains.each do |op|
                 
                 unless op.slaver
-                    sub_str = op.instance(:assign)
+                    sub_str = op.instance(:assign,belong_to_module)
                     # if sub_str =~ /^(?<head>[\w\.\[\]\:]+\s*)(?<eq><?=\s*)\((?<body>.+)\)$/
                     #     rel_str = $~[:head] + $~[:eq] + $~[:body]
                     # else 

data/lib/tdl/class_hdl/hdl_block_ifelse.rb

@@ -11,7 +11,7 @@ module ClassHDL
 
         def instance(as_type= :cond)
             if cond.is_a? ClassHDL::OpertorChain
-                head_str = "if(#{cond.instance(:cond)})begin"
+                head_str = "if(#{cond.instance(:cond, belong_to_module)})begin"
             else 
                 head_str = "if(#{cond.to_s})begin"
             end
@@ -20,7 +20,7 @@ module ClassHDL
             opertor_chains.each do |oc|
                 unless oc.is_a? BlockIF
                     unless oc.slaver
-                        rel_str = ClassHDL.compact_op_ch(oc.instance(as_type))
+                        rel_str = ClassHDL.compact_op_ch(oc.instance(as_type, belong_to_module))
                         sub_str.push "    #{rel_str};"
                     end
                 else 
@@ -36,7 +36,7 @@ module ClassHDL
     class BlockELSIF < BlockIF
         def instance(as_type= :cond)
             if cond.is_a? ClassHDL::OpertorChain
-                head_str = "else if(#{cond.instance(:cond)})begin"
+                head_str = "else if(#{cond.instance(:cond, belong_to_module)})begin"
             else 
                 head_str = "else if(#{cond.to_s})begin"
             end
@@ -45,7 +45,7 @@ module ClassHDL
             opertor_chains.each do |oc|
                 unless oc.is_a? BlockIF
                     unless oc.slaver
-                        sub_str.push "    #{oc.instance(as_type)};"
+                        sub_str.push "    #{oc.instance(as_type, belong_to_module)};"
                     end
                 else 
                     sub_str.push( oc.instance(as_type).gsub(/^./){ |m| "    #{m}"} )
@@ -66,7 +66,7 @@ module ClassHDL
             opertor_chains.each do |oc|
                 unless oc.is_a? BlockIF
                     unless oc.slaver
-                        sub_str.push "    #{oc.instance(as_type)};"
+                        sub_str.push "    #{oc.instance(as_type, belong_to_module)};"
                     end
                 else 
                     sub_str.push( oc.instance(as_type).gsub(/^./){ |m| "    #{m}"} )
@@ -135,7 +135,7 @@ module ClassHDL
             opertor_chains.each do |oc|
                 unless oc.is_a? BlockIF
                     unless oc.slaver
-                        sub_str.push "    #{oc.instance(as_type)};"
+                        sub_str.push "    #{oc.instance(as_type, belong_to_module)};"
                     end
                 else 
                     sub_str.push( oc.instance(as_type).gsub(/^./){ |m| "    #{m}"} )
@@ -168,7 +168,7 @@ module ClassHDL
             opertor_chains.each do |oc|
                 unless oc.is_a? BlockIF
                     unless oc.slaver
-                        sub_str.push "    #{oc.instance(as_type)};"
+                        sub_str.push "    #{oc.instance(as_type, belong_to_module)};"
                     end
                 else 
                     sub_str.push( oc.instance(as_type).gsub(/^./){ |m| "    #{m}"} )

data/lib/tdl/class_hdl/hdl_foreach.rb

@@ -10,7 +10,7 @@ module ClassHDL
             opertor_chains.each do |oc|
                 unless oc.is_a? BlockIF
                     unless oc.slaver
-                        sub_str.push "    #{oc.instance(as_type)};"
+                        sub_str.push "    #{oc.instance(as_type, belong_to_module)};"
                     end
                 else 
                     sub_str.push( oc.instance(as_type).gsub(/^./){ |m| "    #{m}"} )
@@ -36,7 +36,7 @@ module ClassHDL
             opertor_chains.each do |oc|
                 unless oc.is_a? BlockIF
                     unless oc.slaver
-                        sub_str.push "    #{oc.instance(as_type)};"
+                        sub_str.push "    #{oc.instance(as_type,belong_to_module)};"
                     end
                 else 
                     sub_str.push( oc.instance(as_type).gsub(/^./){ |m| "    #{m}"} )

data/lib/tdl/class_hdl/hdl_function.rb

@@ -13,7 +13,7 @@ module ClassHDL
             if @func_inst.return_type.is_a? StructMeta
                 @func_inst.return_type.struct_slots.each do |e|
                     self.define_singleton_method(e.name) do 
-                        TdlSpace::ArrayChain.new("#{@func_inst.name}.#{e.name}".to_nq)
+                        TdlSpace::ArrayChain.create(obj: "#{@func_inst.name}.#{e.name}".to_nq, belong_to_module: @func_inst.belong_to_module )
                     end
                 end
             end
@@ -90,7 +90,7 @@ module ClassHDL
                     str.push op.instance(:assign).gsub(/^./){ |m| "    #{m}"}
                 else 
                     unless op.slaver
-                        rel_str = ClassHDL.compact_op_ch(op.instance(:assign))
+                        rel_str = ClassHDL.compact_op_ch(op.instance(:assign,belong_to_module))
                         str.push "    #{rel_str};"
                     end
                 end
@@ -193,7 +193,7 @@ module ClassHDL
                 # pin,iostd = parse_pin_prop(pin_prop) if pin_prop
                 # RedefOpertor.with_normal_operators do
                 ClassHDL::AssignDefOpertor.with_rollback_opertors(:old) do 
-                    tmp = Logic.new(name:name,dsize:dsize,port:"input",dimension:dimension)
+                    tmp = Logic.new(name:name,dsize:dsize,port:"input",dimension:dimension, belong_to_module: self)
                     # add_to_new_module("@port_logics",tmp)
                     # add_method_to_itgt(name,tmp)
                     tmp
@@ -205,7 +205,7 @@ module ClassHDL
                 # pin,iostd = parse_pin_prop(pin_prop) if pin_prop
                 # RedefOpertor.with_normal_operators do
                 ClassHDL::AssignDefOpertor.with_rollback_opertors(:old) do
-                    tmp = Logic.new(name:name,dsize:dsize,port:"output logic",dimension:dimension)
+                    tmp = Logic.new(name:name,dsize:dsize,port:"output logic",dimension:dimension, belong_to_module: self)
                     # add_to_new_module("@port_logics",tmp)
         
                     if block_given?

data/lib/tdl/class_hdl/hdl_generate.rb

@@ -20,6 +20,9 @@ module ClassHDL
         def initialize(belong_to_module)
             @belong_to_module = belong_to_module
             super("genblk#{globle_random_name_flag()}")
+            unless @belong_to_module
+                raise TdlError.new("GenerateBlock must have belong_to_module")
+            end
         end
 
 
@@ -41,7 +44,7 @@ module ClassHDL
         def IF(cond,&block)
             if ClassHDL::AssignDefOpertor.curr_assign_block.is_a? HDLAssignGenerateBlock
                 if cond.respond_to?(:instance)
-                    head_str = "\nif(#{cond.instance(:cond)})begin\n"
+                    head_str = "\nif(#{cond.instance(:cond, @belong_to_module)})begin\n"
                 else 
                     head_str = "\nif(#{cond})begin\n"
                 end

data/lib/tdl/class_hdl/hdl_initial.rb

@@ -7,6 +7,9 @@ module ClassHDL
         def initialize(belong_to_module)
             @opertor_chains = []
             @belong_to_module = belong_to_module
+            unless @belong_to_module 
+                raise TdlError.new("HDLInitialBlock must have belong_to_module")
+            end
         end
 
         def instance(block_name=nil)
@@ -17,7 +20,26 @@ module ClassHDL
                     str.push op.instance(:assign).gsub(/^./){ |m| "    #{m}"}
                 else 
                     unless op.slaver
-                        rel_str = ClassHDL.compact_op_ch(op.instance(:assign))
+                        rel_str = ClassHDL.compact_op_ch(op.instance(:assign, belong_to_module))
+                        str.push "    #{rel_str};"
+                    end
+                end
+                
+            end
+            str.push "end\n"
+            str.join("\n")
+        end
+
+        def instance_inspect()
+            str = []
+            block_name=nil
+            str.push "initial begin#{block_name ? ':'.concat(block_name.to_s) : ''}"
+            opertor_chains.each do |op|
+                unless op.is_a? OpertorChain
+                    str.push op.instance(:assign).gsub(/^./){ |m| "    #{m}"}
+                else 
+                    unless op.slaver
+                        rel_str = ClassHDL.compact_op_ch(op.instance(:assign,belong_to_module))
                         str.push "    #{rel_str};"
                     end
                 end
@@ -41,7 +63,7 @@ module ClassHDL
     class BlocAssertIF < BlockIF
         def instance(as_type= :cond)
             if cond.is_a? ClassHDL::OpertorChain
-                head_str = "assert(#{cond.instance(:cond)})else begin"
+                head_str = "assert(#{cond.instance(:cond, belong_to_module)})else begin"
             else 
                 head_str = "assert(#{cond.to_s})else begin"
             end
@@ -50,7 +72,7 @@ module ClassHDL
             opertor_chains.each do |oc|
                 unless oc.is_a? BlockIF
                     unless oc.slaver
-                        sub_str.push "    #{oc.instance(as_type)};"
+                        sub_str.push "    #{oc.instance(as_type,belong_to_module)};"
                     end
                 else 
                     sub_str.push( oc.instance(as_type).gsub(/^./){ |m| "    #{m}"} )

data/lib/tdl/class_hdl/hdl_module_def.rb

@@ -170,6 +170,9 @@ module ClassHDL
         def initialize(sdlm,args={})
             @chain = []
             @sdlm = sdlm
+            unless @sdlm 
+                raise TdlError.new("ImplicitPortBase<#{args.to_s}> dont have belong_to_module")
+            end
             @up_args = args
         end
 
@@ -298,7 +301,7 @@ module ClassHDL
             if sub_type.is_a? StructMeta
                 @sub_type.struct_slots.each do |e|
                     obj.define_singleton_method(e.name) do 
-                        TdlSpace::ArrayChain.new("#{obj.name}.#{e.name}".to_nq)
+                        TdlSpace::ArrayChain.create(obj: "#{obj.name}.#{e.name}".to_nq, belong_to_module: obj.belong_to_module)
                     end
                 end
             end
@@ -380,27 +383,27 @@ class SdlModule
 
     def >>(*args)
         str = "{>>{#{args.map{|e| e.to_s }.join(',')}}}"
-        TdlSpace::ArrayChain.new(str)
+        TdlSpace::ArrayChain.create(obj: str, belong_to_module: self)
     end
 
     def <<(*args)
         str = "{<<{#{args.map{|e| e.to_s }.join(',')}}}"
-        TdlSpace::ArrayChain.new(str)
+        TdlSpace::ArrayChain.create(obj: str, belong_to_module: self)
     end
 
     def logic_bind_(*args)
         str = "{#{args.map{|e| e.to_s }.join(',')}}"
-        TdlSpace::ArrayChain.new(str)
+        TdlSpace::ArrayChain.create(obj: str, belong_to_module: self)
     end
 
     def clog2(arg)
         str = "$clog2(#{arg.to_s})"
-        TdlSpace::ArrayChain.new(str)
+        TdlSpace::ArrayChain.create(obj: str, belong_to_module: self)
     end
 
     def bits(arg)
         str = "$bits(#{arg.to_s})"
-        TdlSpace::ArrayChain.new(str)
+        TdlSpace::ArrayChain.create(obj: str, belong_to_module: self)
     end
 
 end

data/lib/tdl/class_hdl/hdl_package.rb

@@ -90,6 +90,51 @@ module ClassHDL
             return str
         end
 
+        def build_module_verb(ex_param: "",ex_port: "",ex_up_code: "",ex_down_code: "")
+            # Tdl.Puts pagination(module_name)
+            Tdl.Build_SdlModule_Puts(module_name)
+    
+            ex_param        = ex_param.to_s     unless ex_param
+            ex_port         = ex_port.to_s      unless ex_port
+            ex_up_code      = ex_up_code.to_s   unless ex_up_code
+            ex_down_code    = ex_down_code.to_s unless ex_down_code
+    
+            # gen_auto_method     # auto generate class method for interface
+            # draw = Tdl.inst + Tdl.draw
+    
+            instance_draw_str = instance_draw       # It must run before vars_define_inst,because some signals define when inst
+            vars_exec_inst_str = vars_exec_inst     # It must run before vars_define_inst,because some signals define when vars exec
+    
+            post_str = post_inst_stack_call()
+    
+            unless post_str.strip.empty?
+                post_str = pagination("ROOT REF") + post_str
+            end
+    
+            draw = pagination("define") + vars_define_inst + pagination("instance") + instance_draw_str + pagination("expression") + vars_exec_inst_str + post_str
+    
+            unless ex_up_code.empty?
+                ex_up_code = "\n//------>> EX CODE <<-------------------\n" + ex_up_code + "//------<< EX CODE >>-------------------\n"
+            end
+    
+            unless ex_down_code.empty?
+                ex_down_code = "//------>> EX CODE <<-------------------\n" + ex_down_code + "//------<< EX CODE >>-------------------\n"
+            end
+    
+
+            module_name_str = @module_name
+    
+    
+            # str = module_head+"package #{module_name_str};\n"  + build_params(ex_param) + ex_up_code + draw + ex_down_code + "\nendpackage:#{module_name_str}\n" + add_sub_module_file_paths
+            str = "package #{module_name_str};\n"  + build_params(ex_param) + ex_up_code + draw + ex_down_code + "\nendpackage:#{module_name_str}\n" + add_sub_module_file_paths
+
+            create_vivado_tcl if @create_tcl
+            create_constraints_file if @create_sdc
+    
+            return [module_head_verb,str]
+        end
+
+
     end
 
     # class ReqPakcgeLine

data/lib/tdl/class_hdl/hdl_redefine_opertor.rb

@@ -47,6 +47,20 @@ module ClassHDL
                 @tree << arg 
             end  
             @belong_to_module = belong_to_module
+            unless @belong_to_module
+                raise TdlError.new("OpertorChain must have belong_to_module")
+            end
+        end
+
+        def instance_inspect
+            str = ["self belong_to_module:#{belong_to_module.module_name}"]
+            index = 0
+            @tree.each do |node|
+                bl = "#{node[0].respond_to?(:belong_to_module) ? "belong_to_module:#{node[0].belong_to_module.module_name }" : '' }"
+                str << "{{ tree[#{index}][1]node[1]SYMB{#{node[1].to_s}} tree[#{index}][0]node[0]#{node[0].to_s} #{node[0].class} #{bl}}}"
+                index += 1
+            end
+            str.join(" ")
         end
 
         ClassHDL::OP_SYMBOLS.each do |os|
@@ -103,17 +117,20 @@ module ClassHDL
             # self.nege = true
             # return self
             self.slaver = true
-            new_op = OpertorChain.new(["~(#{self.instance})".to_nq])
+            bel = belong_to_module || ( @tree[0][0].respond_to?(:belong_to_module) && @tree[0][0].belong_to_module )
+            new_op = OpertorChain.new(["~(#{self.instance(:assign, bel)})".to_nq])
         end
 
         def brackets
             self.slaver = true
-            new_op = OpertorChain.new(["(#{self.instance})".to_nq], belong_to_module)
+            bel = ( @tree[0][0].respond_to?(:belong_to_module) && @tree[0][0].belong_to_module )
+            new_op = OpertorChain.new(["(#{self.instance(:assign, belong_to_module || bel)})".to_nq], belong_to_module)
         end
 
         def clog2
             self.slaver = true
-            new_op = OpertorChain.new(["$clog2(#{self.instance})".to_nq],belong_to_module)
+            bel = belong_to_module || ( @tree[0][0].respond_to?(:belong_to_module) && @tree[0][0].belong_to_module )
+            new_op = OpertorChain.new(["$clog2(#{self.instance(:aasign, bel)})".to_nq],belong_to_module)
         end
 
         def self.define_op_flag(ruby_op,hdl_op)
@@ -143,10 +160,13 @@ module ClassHDL
 
 
         def to_s 
-            instance(type=:cond)
+            instance(type=:cond,belong_to_module || ( @tree[0][0].respond_to?(:belong_to_module) && @tree[0][0].belong_to_module ) )
         end
 
-        def instance(type=:assign)
+        def instance(type=:assign,block_belong_to_module=nil,show=nil)
+            unless block_belong_to_module
+                raise TdlError.new("OpertorChain must has block_belong_to_module")
+            end
             AssignDefOpertor.with_rollback_opertors(:old) do 
                 str = ''
                 # both_symb_used = false
@@ -160,39 +180,75 @@ module ClassHDL
                                 sb = " = "
                             end 
                         else 
-                            # if(node[1].respond_to?(:belong_to_module) && node[1].belong_to_module && node[1].belong_to_module != belong_to_module)
-                            #     sb = "#{node[1].root_ref.to_s}"
-                            # else
-                                sb = "#{node[1].to_s}"
-                            # end
+
+                            sb = "#{node[1].to_s}"
                         end
                     else
-                        # if(node[1].respond_to?(:belong_to_module) && node[1].belong_to_module && node[1].belong_to_module != belong_to_module)
-                        #     sb = "#{node[1].root_ref.to_s}"
-                        # else
-                            sb = "#{node[1].to_s}"
-                        # end
+                        sb = "#{node[1].to_s}"
+                    end
+
+                    if cnt==1 && show 
+                        puts "tree[1][1]<#{node[1]}> 使用 #{sb}"
                     end
                     
                     unless node[0].is_a? OpertorChain
                         ## 判断是不是属于 Var <= "String" 形式
                         if (@tree.length == 2) && node[0].instance_of?(String) && !@slaver
                             str += (sb + '"' + node[0].to_s + '"')
+                            if show 
+                                puts "tree 长度等于2; tree[#{cnt}][0] is string; op is not slaver"
+                            end
                         elsif node[0].instance_of?(String)
                             # "如果是字符串 则原始输出"
                             str += (sb + '"' + node[0].to_s + '"')
+                            if show 
+                                puts "tree[#{cnt}][0] is string"
+                            end
                         else 
                             # str += (sb + node[0].to_s)
-                            if(node[0].respond_to?(:root_ref) && node[0].respond_to?(:belong_to_module) && node[0].belong_to_module && (node[0].belong_to_module != belong_to_module) && node[0].belong_to_module.top_tb_ref? )
+                            if block_belong_to_module
+                                if (node[0].respond_to?(:root_ref) && node[0].respond_to?(:belong_to_module) && node[0].belong_to_module && (node[0].belong_to_module != block_belong_to_module) && node[0].belong_to_module.top_tb_ref? )
+                                    
+                                    str += (sb + node[0].root_ref)
+
+                                    if show 
+                                        puts "tree[#{cnt}][0].belong_to_module<#{node[0].belong_to_module.module_name}> != block_belong_to_module<#{block_belong_to_module.module_name}>"
+                                    end
+                                    ## 反向添加到 TestUnitModule
+                                    if block_belong_to_module.is_a?(TestUnitModule)
+                                        block_belong_to_module.add_root_ref_ele(node[0])
+                                        if show 
+                                            puts "block_belong_to_module<#{block_belong_to_module.module_name}> is TestUnitModule"
+                                        end
+                                    end
+                                else  
+                                    str += (sb + node[0].to_s)
+                                    if show
+                                        mmm =  node[0].respond_to?(:belong_to_module) && node[0].belong_to_module.module_name
+                                        puts "tree[#{cnt}][0]<#{node[0].class}>: ref_root<#{node[0].respond_to?(:root_ref).to_s}> belong_to_module<#{mmm}> block_belong_to_module<#{block_belong_to_module.module_name}> ...."
+                                    end
+                                end
+                            elsif(node[0].respond_to?(:root_ref) && node[0].respond_to?(:belong_to_module) && node[0].belong_to_module && (node[0].belong_to_module != belong_to_module) && node[0].belong_to_module.top_tb_ref? )
                                 # sb = "#{node[1].root_ref.to_s}"
                                 str += (sb + node[0].root_ref)
+
+                                if show 
+                                    puts "tree[#{cnt}][0].belong_to_module<#{node[0].belong_to_module.module_name}> != op.belong_to_module<#{belong_to_module.module_name}>"
+                                end
+
                                 ## 反向添加到 TestUnitModule
                                 if belong_to_module.is_a?(TestUnitModule)
                                     belong_to_module.add_root_ref_ele(node[0])
+                                    if show 
+                                        puts "tree[#{cnt}][0]: op.belong_to_module<#{belong_to_module.module_name}> is TestUnitModule"
+                                    end
                                 end
                             else
                                 # sb = "#{node[1].to_s}"
                                 str += (sb + node[0].to_s)
+                                if show 
+                                    puts "tree[#{cnt}][0]: op.belong_to_module<#{belong_to_module.module_name}> ..."
+                                end
                             end
                         end
                     else 
@@ -203,13 +259,17 @@ module ClassHDL
                         # if node[0].tree.length>2 && ["&","|","<",">"].include?(node[0].tree[1][1])
 
                         # else
+                    
                         if sb =~/(\||&){2,2}/
-                            str += " #{sb}#{node[0].instance(:slaver).to_s}"
+                            str += " #{sb}#{node[0].instance(:slaver,block_belong_to_module || belong_to_module).to_s}"
                         else
-                            str += "#{sb}(#{node[0].instance(:slaver).to_s})"
+                            str += "#{sb}(#{node[0].instance(:slaver,block_belong_to_module || belong_to_module).to_s})"
                         end
-                        # end
-                        # str += "#{sb}(#{"Node"})"
+                        
+                        if show 
+                            puts "tree[#{cnt}][0] is op, block_belong_to_module<#{block_belong_to_module.to_s}> op.belong_to_module<#{belong_to_module.to_s}>"
+                        end
+
                     end
                     cnt += 1
                 end
@@ -235,8 +295,10 @@ module ClassHDL
 
     module AssignDefOpertor
         @@included_class = []
-        @@curr_assign_block = HDLAssignBlock.new(nil) ##HDLAssignBlock ##HDLAlwaysCombBlock
-        @@curr_assign_block_stack = [HDLAssignBlock.new(nil) ]
+        @@curr_assign_block = HDLAssignBlock.new(true) ##HDLAssignBlock ##HDLAlwaysCombBlock
+        # @@curr_assign_block = nil
+        @@curr_assign_block_stack = [HDLAssignBlock.new(true) ]
+        # @@curr_assign_block_stack = []
         @@curr_opertor_stack = [:old]
 
         def self.curr_opertor_stack
@@ -296,7 +358,18 @@ module ClassHDL
                         b.slaver = true 
                     end
                     ## 当 进行 X < Y 等运算时OpertorChain 需要获取 assign block的 belong_to_module
-                    new_op = OpertorChain.new(nil,@@curr_assign_block && @@curr_assign_block.belong_to_module) 
+                    if @@curr_assign_block 
+                        bblm = @@curr_assign_block.belong_to_module
+                    elsif self.respond_to?(:belong_to_module)
+                        bblm = self.belong_to_module
+                    elsif b.respond_to?(:belong_to_module)
+                        bblm = b.belong_to_module
+                        
+                    else
+                        bblm = nil 
+                    end
+
+                    new_op = OpertorChain.new(nil, bblm) 
                     new_op.tree.push([self])
                     new_op.tree.push([b,symb])
                     if @@curr_assign_block
@@ -511,7 +584,7 @@ class BaseElm
                             
                             @_array_chain_hash_[name.to_s] = rel
                         end
-                        TdlSpace::ArrayChain.new(@_array_chain_hash_[name.to_s],[])
+                        TdlSpace::ArrayChain.create(obj: @_array_chain_hash_[name.to_s], lchain:[], belong_to_module: self.belong_to_module)
                     end
                 end
             end
@@ -576,9 +649,8 @@ module TdlSpace
             end
             ClassHDL::AssignDefOpertor.with_rollback_opertors(:old) do
                 unless b 
-                    ArrayChain.new(obj,chain+[a])
+                    ArrayChain.create(obj: obj,lchain: chain+[a],belong_to_module: belong_to_module)
                 else 
-                    # ArrayChain.new(&obj,chain,[a,b])
                     @end_slice = [a,b]
                     self
                 end
@@ -610,7 +682,7 @@ module TdlSpace
         end
 
         def ~
-            ArrayChain.new("~#{self.to_s}")
+            ArrayChain.create(obj: "~#{self.to_s}", belong_to_module: belong_to_module)
         end
     end 
 end