axi_tdl 0.0.12 → 0.1.3

data/lib/tdl/class_hdl/hdl_initial.rb

@@ -3,9 +3,13 @@ module ClassHDL
 
     class HDLInitialBlock 
         attr_accessor :opertor_chains
-
-        def initialize
+        attr_reader :belong_to_module
+        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)
@@ -16,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
@@ -28,7 +51,7 @@ module ClassHDL
     end
 
     def self.Initial(sdl_m,block_name=nil,&block)
-        ClassHDL::AssignDefOpertor.with_new_assign_block(ClassHDL::HDLInitialBlock.new) do |ab|
+        ClassHDL::AssignDefOpertor.with_new_assign_block(ClassHDL::HDLInitialBlock.new(sdl_m)) do |ab|
             AssignDefOpertor.with_rollback_opertors(:new,&block)
             # return ClassHDL::AssignDefOpertor.curr_assign_block
             AssignDefOpertor.with_rollback_opertors(:old) do
@@ -40,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
@@ -49,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}"} )
@@ -82,7 +105,7 @@ class SdlModule
             return assert_old(cond,argv_str=formats,&block)
         end
 
-        new_op = ClassHDL::BlocAssertIF.new
+        new_op = ClassHDL::BlocAssertIF.new(self)
         ClassHDL::AssignDefOpertor.with_new_assign_block(new_op) do |ab|
             if cond.is_a? ClassHDL::OpertorChain
                 cond.slaver = true
@@ -102,7 +125,7 @@ class SdlModule
     end
 
     def assert_old(cond,argv_str=nil,&block)
-        new_op = ClassHDL::BlocAssertIF.new
+        new_op = ClassHDL::BlocAssertIF.new(self)
         # if ClassHDL::AssignDefOpertor.curr_assign_block.is_a? ClassHDL::BlockIF
         #     new_op.slaver = true
         # end
@@ -130,17 +153,17 @@ class SdlModule
     end
 
     def assert_error(argv_str)
-        ClassHDL::AssignDefOpertor.curr_assign_block.opertor_chains.push(ClassHDL::OpertorChain.new(["$error(\"#{argv_str}\")".to_nq]))
-        ClassHDL::AssignDefOpertor.curr_assign_block.opertor_chains.push(ClassHDL::OpertorChain.new(["$stop".to_nq]))
+        ClassHDL::AssignDefOpertor.curr_assign_block.opertor_chains.push(ClassHDL::OpertorChain.new(["$error(\"#{argv_str}\")".to_nq], self))
+        ClassHDL::AssignDefOpertor.curr_assign_block.opertor_chains.push(ClassHDL::OpertorChain.new(["$stop".to_nq], self))
     end
 
     def assert_format_error(formats=[],args=[])
-        ClassHDL::AssignDefOpertor.curr_assign_block.opertor_chains.push(ClassHDL::OpertorChain.new(["$error(\"#{formats.join(' ')}\",#{args.map{|s| s.to_s}.join(',')})".to_nq]))
-        ClassHDL::AssignDefOpertor.curr_assign_block.opertor_chains.push(ClassHDL::OpertorChain.new(["$stop".to_nq]))
+        ClassHDL::AssignDefOpertor.curr_assign_block.opertor_chains.push(ClassHDL::OpertorChain.new(["$error(\"#{formats.join(' ')}\",#{args.map{|s| s.to_s}.join(',')})".to_nq], self))
+        ClassHDL::AssignDefOpertor.curr_assign_block.opertor_chains.push(ClassHDL::OpertorChain.new(["$stop".to_nq], self))
     end
 
     def initial_exec(str)
-        ClassHDL::AssignDefOpertor.curr_assign_block.opertor_chains.push(ClassHDL::OpertorChain.new([str.to_s.to_nq]))
+        ClassHDL::AssignDefOpertor.curr_assign_block.opertor_chains.push(ClassHDL::OpertorChain.new([str.to_s.to_nq], self))
     end
 
     alias_method :always_sim_exec, :initial_exec

data/lib/tdl/class_hdl/hdl_module_def.rb

@@ -70,6 +70,9 @@ module ClassHDL
         def initialize(name,sdlm)
             @name = name
             @sdlm = sdlm
+            unless SdlModule.exist_module?(@name)
+                raise TdlError.new("Cant find module `#{name}` !!!")
+            end
         end
 
         def inst(dname,&block)
@@ -95,9 +98,23 @@ module ClassHDL
             # else 
             #     @sdlm.Instance(@name,dname.to_s,&block)
             # end
+            rel = nil
             AssignDefOpertor.with_rollback_opertors(:old) do 
-                inst(dname,&block)
+                if block_given?
+                    rel = inst(dname,&block)
+                else
+                    ## 当没有block 判断 sdlm是否相应方法
+                    # if @sdlm.has_signal?(dname)
+                    # if SdlModule.call_module(@name).has_signal?(dname)
+                    if SdlModule.call_module(@name).respond_to?(dname)
+                        rel =  SdlModule.call_module(@name).signal(dname)
+                    else 
+                        # super 
+                        raise TdlError.new( "Cant find signal `#{dname}` in module `#{@name}` path: #{SdlModule.call_module(@name).real_sv_path } !!!" )
+                    end
+                end
             end
+            return rel
         end
 
     end
@@ -153,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
 
@@ -281,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
@@ -363,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

@@ -39,13 +39,28 @@ module ClassHDL
 
     class OpertorChain
         attr_accessor :slaver,:tree,:instance_add_brackets
-
-        def initialize(arg=nil)
+        attr_reader :belong_to_module
+        def initialize(arg, belong_to_module)
             @tree = [] #[[inst0,symb0],[inst1,symb1],[other_chain,symb2],[other_chain,symb3]]
                        # self <symb0> inst0 <symb1> inst1 <symb2> ( other_chain ) <symb3> ( other_chain )
             if arg 
                 @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|
@@ -61,14 +76,14 @@ module ClassHDL
                 new_op = nil
                 AssignDefOpertor.with_rollback_opertors(:old) do 
                     if tree.size == 2 && tree.last[1].to_s == "<="
-                        new_op =  OpertorChain.new 
+                        new_op =  OpertorChain.new(nil,belong_to_module) 
                         new_op.tree = new_op.tree + self.tree
                         new_op.tree.push [b,os] 
                     elsif  tree.size >= 2 && (!['*',"/","~"].include?(tree.last[1].to_s))
                         new_op =  brackets 
                         new_op.tree.push [b,os] 
                     else
-                        new_op =  OpertorChain.new 
+                        new_op =  OpertorChain.new(nil,belong_to_module)  
                         new_op.tree = new_op.tree + self.tree
                         new_op.tree.push [b,os] 
                     end 
@@ -102,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])
+            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])
+            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)
@@ -126,7 +144,7 @@ module ClassHDL
                 # 计算生成新的OpertorChain 是 self 也需要抛弃
                 self.slaver = true
                 # return self
-                new_op =  OpertorChain.new 
+                new_op =  OpertorChain.new(nil, belong_to_module) 
                 new_op.tree = new_op.tree + self.tree
                 new_op.tree.push [b,hdl_op] 
     
@@ -142,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
@@ -159,21 +180,76 @@ module ClassHDL
                                 sb = " = "
                             end 
                         else 
+
                             sb = "#{node[1].to_s}"
                         end
                     else
-                        sb = "#{node[1].to_s} "
+                        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)
+                            # str += (sb + node[0].to_s)
+                            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 
                         node[0].slaver = true
@@ -183,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
@@ -215,8 +295,10 @@ module ClassHDL
 
     module AssignDefOpertor
         @@included_class = []
-        @@curr_assign_block = HDLAssignBlock.new ##HDLAssignBlock ##HDLAlwaysCombBlock
-        @@curr_assign_block_stack = [HDLAssignBlock.new ]
+        @@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
@@ -275,7 +357,19 @@ module ClassHDL
                     if b.is_a? OpertorChain
                         b.slaver = true 
                     end
-                    new_op = OpertorChain.new 
+                    ## 当 进行 X < Y 等运算时OpertorChain 需要获取 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
@@ -490,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
@@ -555,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
@@ -589,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
@@ -642,7 +735,7 @@ module TdlSpace
 end
 
 module ClassHDL
-    class StructVar 
+    class StructVar < AxiTdl::SdlModuleActiveBaseElm
         include ClassHDL::AssignDefOpertor
     end 
 end