Class: HDLRuby::High::Behavior

Inherits:
Low::Behavior show all
Includes:
RCSimBehavior
Defined in:
lib/HDLRuby/hruby_high.rb,
lib/HDLRuby/hruby_rsim.rb,
lib/HDLRuby/hruby_rcsim.rb,
lib/HDLRuby/hruby_high_fullname.rb

Overview

Describes a behavior.

Constant Summary collapse

High = 
HDLRuby::High

Constants included from Low::Low2Symbol

Low::Low2Symbol::Low2SymbolPrefix, Low::Low2Symbol::Low2SymbolTable, Low::Low2Symbol::Symbol2LowTable

Instance Attribute Summary

Attributes included from RCSimBehavior

#rcbehavior

Attributes inherited from Low::Behavior

#block

Attributes included from Low::Hparent

#parent

Instance Method Summary collapse

Methods included from RCSimBehavior

#add_sub_events, #to_rcsim

Methods inherited from Low::Behavior

#add_event, #blocks2seq!, #break_concat_assigns!, #delete_event!, #each_block, #each_block_deep, #each_deep, #each_event, #each_node_deep, #each_statement, #eql?, #explicit_types!, #extract_declares!, #fix_scope_refnames!, #get_by_name, #has_event?, #hash, #last_statement, #map_events!, #mixblocks2seq!, #on_edge?, #on_event?, #parent_system, #replace_names!, #reverse_each_statement, #set_block!, #signal2subs!, #to_c, #to_ch, #to_hdr, #to_high, #to_upper_space!, #to_vhdl, #top_scope, #with_boolean!, #with_var!

Methods included from Low::Low2Symbol

#to_sym

Methods included from Low::Hparent

#absolute_ref, #hierarchy, #no_parent!, #scope

Constructor Details

#initialize(mode, *events, &ruby_block) ⇒ Behavior

Creates a new behavior executing +block+ activated on a list of +events+, and built by executing +ruby_block+. +mode+ can be either :seq or :par for respectively sequential or parallel.



4564
4565
4566
4567
4568
4569
4570
4571
4572
4573
4574
4575
4576
4577
 
# File 'lib/HDLRuby/hruby_high.rb', line 4564

def initialize(mode,*events,&ruby_block)
    # Initialize the behavior with it.
    super(nil)
    # # Save the Location for debugging information
    # @location = caller_locations
    # # Sets the current behavior
    # @@cur_behavior = self
    # Add the events (they may be hierarchical to flatten)
    events.flatten.each { |event| self.add_event(event) }
    # Create and add the block.
    self.block = High.make_block(mode,&ruby_block)
    # # Unset the current behavior
    # @@cur_behavior = nil
end

Instance Method Details

#execute(mode) ⇒ Object

Execute the expression.



398
399
400
 
# File 'lib/HDLRuby/hruby_rsim.rb', line 398

def execute(mode)
    return self.block.execute(mode)
end

#fullname ⇒ Object

Returns the name of the signal with its hierarchy.



460
461
462
 
# File 'lib/HDLRuby/hruby_rsim.rb', line 460

def fullname
    return self.parent.fullname
end

#init_sim(systemT) ⇒ Object

Initialize the simulation for system +systemT+.



403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
 
# File 'lib/HDLRuby/hruby_rsim.rb', line 403

def init_sim(systemT)
    # Add the behavior to the list of untimed objects.
    systemT.add_untimed(self)
    # Process the sensitivity list.
    # Is it a clocked behavior?
    events = self.each_event.to_a
    if events.empty? then
        # No events, this is not a clock behavior.
        # And it is not a time behavior neigther.
        # Generate the events list from the right values.
        # First get the references.
        refs = self.block.each_node_deep.select do |node|
            node.is_a?(RefObject) && !node.leftvalue? && 
                !node.parent.is_a?(RefObject) 
        end.to_a
        # Keep only one ref per signal.
        refs.uniq! { |node| node.fullname }
        # puts "refs=#{refs.map {|node| node.fullname}}"
        # The get the left references: the will be removed from the
        # events.
        left_refs = self.block.each_node_deep.select do |node|
            node.is_a?(RefObject) && node.leftvalue? && 
                !node.parent.is_a?(RefObject) 
        end.to_a
        # Keep only one left ref per signal.
        left_refs.uniq! { |node| node.fullname }
        # Remove the inner signals from the list.
        self.block.each_inner do |inner|
            refs.delete_if {|r| r.fullname == inner.fullname }
        end
        # Remove the left refs.
        left_refs.each do |l| 
            refs.delete_if {|r| r.fullname == l.fullname }
        end
        # Generate the event.
        events = refs.map {|ref| Event.new(:anyedge,ref.clone) }
        # Add them to the behavior for further processing.
        events.each {|event| self.add_event(event) }
    end
    # Now process the events: add the behavior to the corresponding
    # activation list of the signals of the events.
    self.each_event do |event|
        sig = event.ref.object
        case event.type
        when :posedge
            sig.add_posedge(self)
        when :negedge
            sig.add_negedge(self)
        else
            sig.add_anyedge(self)
        end
    end
    # Now process the block.
    self.block.init_sim(systemT)
end

#to_low ⇒ Object

Converts the time behavior to HDLRuby::Low.



4584
4585
4586
4587
4588
4589
4590
4591
4592
4593
4594
4595
4596
4597
4598
4599
4600
 
# File 'lib/HDLRuby/hruby_high.rb', line 4584

def to_low
    # Create an empty low behavior for the result.
    behaviorL = HDLRuby::Low::Behavior.new
    # Then fill it.
    # Create the low level block.
    # blockL = self.block.to_low
    blockL = self.block.to_low(behaviorL)
    # Create the low level events.
    eventLs = self.each_event.map { |event| event.to_low }
    # # Create and return the resulting low level behavior.
    # behaviorL = HDLRuby::Low::Behavior.new(blockL)
    # # For debugging: set the source high object 
    # behaviorL.properties[:low2high] = self.hdr_id
    # self.properties[:high2low] = behaviorL
    eventLs.each(&behaviorL.method(:add_event))
    return behaviorL
end