class ClassHDL::OpertorChain

Attributes

belong_to_module[R]
instance_add_brackets[RW]
slaver[RW]
tree[RW]

Public Class Methods

define_op_flag(ruby_op,hdl_op) click to toggle source
# File lib/tdl/class_hdl/hdl_redefine_opertor.rb, line 136
def self.define_op_flag(ruby_op,hdl_op)
    define_method(ruby_op) do |b|
        if b.is_a? OpertorChain
            b.slaver = true
            unless b.simple_op?
                b.instance_add_brackets = true 
            end
        end   
        # 计算生成新的OpertorChain 是 self 也需要抛弃
        self.slaver = true
        # return self
        new_op =  OpertorChain.new(nil, belong_to_module) 
        new_op.tree = new_op.tree + self.tree
        new_op.tree.push [b,hdl_op] 
    
        if ClassHDL::AssignDefOpertor.curr_assign_block
            ClassHDL::AssignDefOpertor.curr_assign_block.opertor_chains.push(new_op)
        end
        new_op
    end
end
new(arg, belong_to_module) click to toggle source
# File lib/tdl/class_hdl/hdl_redefine_opertor.rb, line 43
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

Public Instance Methods

brackets() click to toggle source
# File lib/tdl/class_hdl/hdl_redefine_opertor.rb, line 124
def brackets
    self.slaver = true
    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
clog2() click to toggle source
# File lib/tdl/class_hdl/hdl_redefine_opertor.rb, line 130
def clog2
    self.slaver = true
    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
instance(type=:assign,block_belong_to_module=nil,show=nil) click to toggle source
# File lib/tdl/class_hdl/hdl_redefine_opertor.rb, line 166
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
        cnt = 0
        @tree.each do |node|
            if cnt==1
                if node[1].to_s=="<="
                    if type==:always_ff || type==:cond
                        sb = " <= "
                    else 
                        sb = " = "
                    end 
                else 

                    sb = "#{node[1].to_s}"
                end
            else
                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 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
                # puts "--------"
                # p node[0].tree
                # puts "========"
                # if node[0].tree.length>2 && ["&","|","<",">"].include?(node[0].tree[1][1])

                # else
            
                if sb =~/(\||&){2,2}/
                    str += " #{sb}#{node[0].instance(:slaver,block_belong_to_module || belong_to_module).to_s}"
                else
                    str += "#{sb}(#{node[0].instance(:slaver,block_belong_to_module || belong_to_module).to_s})"
                end
                
                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

        ## 修饰

        # if nege
        #     str = "~(#{str})"
        # else
        #     str
        # end
        if instance_add_brackets 
            "(#{str})"
        else 
            str
        end
    end
end
instance_inspect() click to toggle source
# File lib/tdl/class_hdl/hdl_redefine_opertor.rb, line 55
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
simple_op?() click to toggle source
# File lib/tdl/class_hdl/hdl_redefine_opertor.rb, line 101
def simple_op?
    ## 判断是不是简单的运算 如 X > 0 ,x & y
    ##[[tmp0[0]], ["FALSE", "&"], [#<ClassHDL::OpertorChain:0x00005557046de088 @tree=[[a_inf.valid], ["1'b0", "|"]], @slaver=true>, "&"]]
    ##[[a_inf.valid], ["1'b0", "|"]
    rel = false
    AssignDefOpertor.with_rollback_opertors(:old) do 
        if tree.size==2 && tree[0].size==1 && !(tree[0][0].is_a?(ClassHDL::OpertorChain)) && !(tree[1][0].is_a?(ClassHDL::OpertorChain))
            rel = true 
        else
            rel = false 
        end
    end
    return rel
end
to_s() click to toggle source
# File lib/tdl/class_hdl/hdl_redefine_opertor.rb, line 162
def to_s 
    instance(type=:cond,belong_to_module || ( @tree[0][0].respond_to?(:belong_to_module) && @tree[0][0].belong_to_module ) )
end