Class: HDLRuby::Low::Chunk

Inherits:
Object
  • Object
show all
Includes:
Hparent
Defined in:
lib/HDLRuby/hruby_low.rb,
lib/HDLRuby/hruby_low2c.rb,
lib/HDLRuby/hruby_low2high.rb,
lib/HDLRuby/backend/hruby_c_allocator.rb

Overview

Extends the chunk class with support for self modification with allocation. NOTE: only work if the chunk is in C language.

Direct Known Subclasses

High::Chunk

Instance Attribute Summary collapse

Attributes included from Hparent

#parent

Instance Method Summary collapse

Methods included from Hparent

#hierarchy, #no_parent!, #scope

Constructor Details

#initialize(name, *lumps) ⇒ Chunk

Creates new code chunk +name+ with made of +lumps+ piece of text.



2732
2733
2734
2735
2736
2737
2738
 
# File 'lib/HDLRuby/hruby_low.rb', line 2732

def initialize(name,*lumps)
    # Check and set the name.
    @name = name.to_sym
    # Set the content.
    @lumps = []
    lumps.each { |lump| self.add_lump(lump) }
end

Instance Attribute Details

#name ⇒ Object (readonly)

The name of the code chunk.



2729
2730
2731
 
# File 'lib/HDLRuby/hruby_low.rb', line 2729

def name
  @name
end

Instance Method Details

#add_lump(lump) ⇒ Object

Adds a +lump+ of code, it is ment to become an expression or some text.



2745
2746
2747
2748
2749
2750
2751
 
# File 'lib/HDLRuby/hruby_low.rb', line 2745

def add_lump(lump)
    # Set its parent if relevant.
    lump.parent = self if lump.respond_to?(:parent)
    # And add it
    @lumps << lump
    return lump
end

#c_code_allocate!(allocator) ⇒ Object

Allocates signal within C code using +allocator+ and self-modify the code correspondingly. NOTE: non-C chunks are ignored.



45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/HDLRuby/backend/hruby_c_allocator.rb', line 45

def c_code_allocate!(allocator)
    # Checks the chunk is actually C.
    return self unless self.name == :c
    # Process each lump.
    @lumps.map! do |lump|
        lump_r = lump.resolve if lump.respond_to?(:resolve)
        if lump_r.is_a?(SignalI) then
            # The lump is a signal, performs the allocation and
            # change it to an address access.
            "*(0x#{allocator.allocate(lump_r).to_s(16)})"
        else
            lump
        end
    end
    self
end

#each_deep(&ruby_block) ⇒ Object

Iterates over each object deeply.

Returns an enumerator if no ruby block is given.



2766
2767
2768
2769
2770
2771
 
# File 'lib/HDLRuby/hruby_low.rb', line 2766

def each_deep(&ruby_block)
    # No ruby block? Return an enumerator.
    return to_enum(:each_deep) unless ruby_block
    # A ruby block? First apply it to current.
    ruby_block.call(self)
end

#each_lump(&ruby_block) ⇒ Object

Iterates over the code lumps.

Returns an enumerator if no ruby block is given.



2756
2757
2758
2759
2760
2761
 
# File 'lib/HDLRuby/hruby_low.rb', line 2756

def each_lump(&ruby_block)
    # No ruby block? Return an enumerator.
    return to_enum(:each_lump) unless ruby_block
    # A ruby block? Apply it on each lump.
    @lumps.each(&ruby_block)
end

#to_c(res, level = 0) ⇒ Object

Generates the C text of the equivalent HDLRuby code. +level+ is the hierachical level of the object. def to_c(level = 0)



1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
 
# File 'lib/HDLRuby/hruby_low2c.rb', line 1106

def to_c(res,level = 0)
    # res = " " * level
    res << " " * level
    # res << self.each_lump.map do |lump|
    #     if !lump.is_a?(String) then
    #         lump.respond_to?(:to_c) ? lump.to_c(level+1) : lump.to_s
    #     else
    #         lump
    #     end
    # end.join
    self.each_lump do |lump|
        if !lump.is_a?(String) then
            if lump.respond_to?(:to_c) then
                lump.to_c(res,level+1)
            else
                res << lump.to_s
            end
        else
            res << lump
        end
    end
    return res
end

#to_high ⇒ Object

Creates a new high code chunk.



208
209
210
211
 
# File 'lib/HDLRuby/hruby_low2high.rb', line 208

def to_high
    return HDLRuby::High::Chunk.new(self.name,
                        *self.each_lump { |lump| lump.to_high })
end