Module: HDLRuby::Tprocess

Included in:
High::Htype
Defined in:
lib/HDLRuby/hruby_types.rb

Overview

To include to classes for type processing support.

Instance Method Summary collapse

Instance Method Details

#&(type) ⇒ Object Also known as: |, ^, <, >, <=, >=, <=>

And



159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
 
# File 'lib/HDLRuby/hruby_types.rb', line 159

def &(type)
    # # puts "compute types with=#{self} and #{type}"
    # # Resolve the type class.
    # resolved = self.resolve(type)
    # 
    # # Logical operation on non-vector types are kept as is.
    # return resolved unless resolved.is_a?(TypeVector)

    # # Otherwise the range is computed.
    # # New type range: largest range 
    # bounds = [ self.range.first.to_i, type.range.first.to_i,
    #            self.range.last.to_i, type.range.last.to_i ]
    # # puts "bounds=#{bounds}"
    # res_lsb =  bounds.min
    # res_msb = bounds.max 
    # # Create and return the new type: its endianess is the one of self
    # if self.range.first.to_i > self.range.last.to_i then
    #     return resolved.make(:"",resolved.base,res_msb..res_lsb)
    # else
    #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
    # end
    # The result is the resolve result now!
    return self.resolve(type)
end

#*(type) ⇒ Object

Multiplication



100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
# File 'lib/HDLRuby/hruby_types.rb', line 100

def *(type)
    # # Resolve the type class.
    # resolved = self.resolve(type)
    # # New type range: largest range * 2
    # bounds = [ self.range.first.to_i, type.range.first.to_i,
    #            self.range.last.to_i, type.range.last.to_i ]
    # res_lsb =  bounds.min
    # res_msb = bounds.max * 2
    # # Create and return the new type: its endianess is the one of self
    # if self.range.first.to_i > self.range.last.to_i then
    #     return resolved.make(:"",resolved.base,res_msb..res_lsb)
    # else
    #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
    # end
    # The result is the resolve result now!
    return self.resolve(type)
end

#+(type) ⇒ Object Also known as: -

Addition.



78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
 
# File 'lib/HDLRuby/hruby_types.rb', line 78

def +(type)
    # # Resolve the type class.
    # resolved = self.resolve(type)
    # # New type range: largest range + 1
    # bounds = [ self.range.first.to_i, type.range.first.to_i,
    #            self.range.last.to_i, type.range.last.to_i ]
    # res_lsb =  bounds.min
    # res_msb = bounds.max + 1
    # # Create and return the new type: its endianess is the one of self
    # if self.range.first.to_i > self.range.last.to_i then
    #     return resolved.make(:"",resolved.base,res_msb..res_lsb)
    # else
    #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
    # end
    # The result is the resolve result now!
    return self.resolve(type)
end

#+@ ⇒ Object

Positive



141
142
143
 
# File 'lib/HDLRuby/hruby_types.rb', line 141

def +@()
    return self
end

#-@ ⇒ Object

Negative



146
147
148
 
# File 'lib/HDLRuby/hruby_types.rb', line 146

def -@()
    return self
end

#/(type) ⇒ Object Also known as: %

Division



119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
 
# File 'lib/HDLRuby/hruby_types.rb', line 119

def /(type)
    # # Resolve the type class.
    # resolved = self.resolve(type)
    # # New type range: largest range 
    # bounds = [ self.range.first.to_i, type.range.first.to_i,
    #            self.range.last.to_i, type.range.last.to_i ]
    # res_lsb =  bounds.min
    # res_msb = bounds.max 
    # # Create and return the new type: its endianess is the one of self
    # if self.range.first.to_i > self.range.last.to_i then
    #     return resolved.make(:"",resolved.base,res_msb..res_lsb)
    # else
    #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
    # end
    # The result is the resolve result now!
    return self.resolve(type)
end

#<<(type) ⇒ Object Also known as: ls, >>, rs

Shift left



221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
 
# File 'lib/HDLRuby/hruby_types.rb', line 221

def <<(type)
    # # The result type is the type of left.
    # resolved = self
    # # New type range: 2**(type width) times self range
    # bounds = [ self.range.first.to_i, self.range.last.to_i ]
    # res_lsb =  bounds.min
    # res_msb = bounds.max +
    #     (2 ** ((type.range.last-type.range.first).abs))
    # # Create and return the new type: its endianess is the one of self
    # if self.range.first.to_i > self.range.last.to_i then
    #     return resolved.make(:"",resolved.base,res_msb..res_lsb)
    # else
    #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
    # end
    # The result is the resolve result now!
    return self.resolve(type)
end

#==(type) ⇒ Object Also known as: !=

Equals alias_method :==, :&



197
198
199
 
# File 'lib/HDLRuby/hruby_types.rb', line 197

def ==(type)
    return Bit
end

#abs ⇒ Object

Absolute value



151
152
153
 
# File 'lib/HDLRuby/hruby_types.rb', line 151

def abs()
    return self
end

#lr(type) ⇒ Object Also known as: rr

Rotate left.



246
247
248
 
# File 'lib/HDLRuby/hruby_types.rb', line 246

def lr(type)
    return self
end

#make(name, base, range) ⇒ Object

Creates a new generic vector type named +name+ from +base+ type and with +range+. NOTE: used for type processing.



15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
# File 'lib/HDLRuby/hruby_types.rb', line 15

def make(name,base,range)
    # Generate a vector or a scalar type depending on the range.
    # First for checking the rangem ensures the bounds are Ruby
    # values.
    first = range.first
    last = range.last
    first = first.content if first.is_a?(Value)
    last = last.content if last.is_a?(Value)
    # Necessarily a TypeVector, since [0..0] has actually a
    # different meaning from [0]!
    # # Now can compare at Ruby level (and not HDLRuby level).
    # if first == last then
    #     # Single-element, return the base.
    #     return base
    # else
    #     # Multiple elements, create a new type vector.
    #     return TypeVector.new(name,base,range)
    # end
    return TypeVector.new(name,base,range)
end

#resolve(type) ⇒ Object

Type resolution: decide which class to use for representing a computating result with +type+.



38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/HDLRuby/hruby_types.rb', line 38

def resolve(type)
    # puts "self=#{self} type=#{type}"
    if self.float? then
        return self
    elsif type.float? then
        return type
    elsif self.signed? then
        return self
    elsif type.signed? then
        return type
    elsif self.unsigned? then
        return self
    elsif type.unsigned? then
        return type
    elsif self.width >= type.width then
        return self
    else
        return type
    end
end

#slice(idx) ⇒ Object

Range access with +idx+ NOTE:

  • +idx+ may be a range.
  • Do not use the [] operator for this since it is used for defining vector types!


64
65
66
67
68
69
70
71
72
 
# File 'lib/HDLRuby/hruby_types.rb', line 64

def slice(idx)
    if idx.is_a?(Range) then
        # Make a resized vector.
        return make(:"",self.base,idx)
    else
        # Return the base type.
        return self.base
    end
end

#~ ⇒ Object

Not



191
192
193
 
# File 'lib/HDLRuby/hruby_types.rb', line 191

def ~()
    return self
end