Class: HDLRuby::Low::Chunk
- Inherits:
-
Object
- Object
- HDLRuby::Low::Chunk
- 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
Instance Attribute Summary collapse
-
#name ⇒ Object
readonly
The name of the code chunk.
Attributes included from Hparent
Instance Method Summary collapse
-
#add_lump(lump) ⇒ Object
Adds a +lump+ of code, it is ment to become an expression or some text.
-
#c_code_allocate!(allocator) ⇒ Object
Allocates signal within C code using +allocator+ and self-modify the code correspondingly.
-
#each_deep(&ruby_block) ⇒ Object
Iterates over each object deeply.
-
#each_lump(&ruby_block) ⇒ Object
Iterates over the code lumps.
-
#initialize(name, *lumps) ⇒ Chunk
constructor
Creates new code chunk +name+ with made of +lumps+ piece of text.
-
#to_c(res, level = 0) ⇒ Object
Generates the C text of the equivalent HDLRuby code.
-
#to_high ⇒ Object
Creates a new high code chunk.
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)
1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 |
# File 'lib/HDLRuby/hruby_low2c.rb', line 1143 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 |