Class: HDLRuby::High::Scope

Inherits:
Low::Scope show all
Includes:
HScope_missing, Hinner, Hmux, SingletonExtend
Defined in:
lib/HDLRuby/hruby_high.rb

Overview

Describes a scope for a system type

Constant Summary collapse

High = 
HDLRuby::High

Constants included from Low::Low2Symbol

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

Instance Attribute Summary collapse

Attributes included from HDLRuby::Hdecorator

#hdr_id

Attributes included from Low::Hparent

#parent

Instance Method Summary collapse

Methods included from Hmux

#mux

Methods included from HScope_missing

#h_missing, #method_missing

Methods included from Hmissing

#method_missing

Methods included from SingletonExtend

#eigen_extend

Methods included from Hinner

included

Methods inherited from Low::Scope

#add_behavior, #add_code, #add_connection, #add_inner, #add_scope, #add_systemI, #add_systemT, #add_type, #blocks2seq!, #boolean_in_assign2select!, #break_concat_assigns!, #break_types!, #c_code_allocate, #casts_without_expression!, #cleanup!, #delete_behavior!, #delete_connection!, #delete_inner!, #delete_related!, #delete_scope!, #delete_systemI!, #delete_systemT!, #delete_type!, #delete_unless!, #each_behavior, #each_behavior_deep, #each_block_deep, #each_code, #each_connection, #each_connection_deep, #each_deep, #each_inner, #each_node_deep, #each_scope, #each_scope_deep, #each_signal, #each_signal_deep, #each_statement_deep, #each_systemI, #each_systemT, #each_type, #eql?, #explicit_types!, #extract_behaviors!, #extract_connections!, #extract_declares!, #extract_port_assign!, #get_all_inners, #get_by_name, #get_code, #get_inner, #get_signal, #get_systemI, #get_systemT, #get_type, #has_behavior?, #has_code?, #has_connection?, #has_inner?, #has_scope?, #has_signal?, #has_systemI?, #has_systemT?, #has_type?, #hash, #initial_concat_to_timed!, #instance_port?, #last_behavior, #make_portw, #map_behaviors!, #map_connections!, #map_inners!, #map_scopes!, #map_systemIs!, #map_systemTs!, #map_types!, #mixblocks2seq!, #par_in_seq2seq!, #parent_system, #port_assign?, #portw2ref, #portw_name2sym, #replace_names!, #replace_names_subs!, #reverse_each_behavior, #select2case!, #sym2portw_name, #to_c, #to_ch, #to_high, #to_upper_space!, #to_vhdl, #top_scope, #with_port!

Methods included from Low::ForceName

#extend_name!, #force_name!

Methods included from Low::Low2Symbol

#to_sym

Methods included from HDLRuby::Hdecorator

decorate_parent_id, dump, each, each_with_property, get, included, load, #properties

Methods included from Low::Hparent

#scope

Constructor Details

#initialize(name = :"", systemT = nil, &ruby_block) ⇒ Scope

Creates a new scope with possible +name+. If the scope is a top scope of a system, this systemT is given by +systemT+.

The proc +ruby_block+ is executed for building the scope. If no block is provided, the scope is the top of a system and is filled by the instantiation procedure of the system.



803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
 
# File 'lib/HDLRuby/hruby_high.rb', line 803

def initialize(name = :"", systemT = nil, &ruby_block)
    # Initialize the scope structure
    super(name)

    # Initialize the set of grouped system instances.
    @groupIs = {}

    # Creates the namespace.
    @namespace = Namespace.new(self)

    # Register the scope if it is not the top scope of a system
    # (in which case the system has already be registered with
    # the same name).
    unless name.empty? or systemT then
        # Named scope, set the hdl-like access to the scope.
        obj = self # For using the right self within the proc
        High.space_reg(name) { obj }
    end

    # Initialize the set of exported inner signals and instances
    @exports = {}
    # Initialize the set of included systems.
    @includes = {}

    # Builds the scope if a ruby block is provided
    # (which means the scope is not the top of a system).
    self.build(&ruby_block) if block_given?
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method in the class HDLRuby::High::HScope_missing

Instance Attribute Details

#name ⇒ Object (readonly)

The name of the scope if any.



787
788
789
 
# File 'lib/HDLRuby/hruby_high.rb', line 787

def name
  @name
end

#namespace ⇒ Object (readonly)

The namespace



790
791
792
 
# File 'lib/HDLRuby/hruby_high.rb', line 790

def namespace
  @namespace
end

#return_value ⇒ Object (readonly)

The return value when building the scope.



793
794
795
 
# File 'lib/HDLRuby/hruby_high.rb', line 793

def return_value
  @return_value
end

Instance Method Details

#add_export(name) ⇒ Object

Adds a +name+ to export.

NOTE: if the name do not corresponds to any inner signal nor instance, raise an exception.

Raises:



874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
 
# File 'lib/HDLRuby/hruby_high.rb', line 874

def add_export(name)
    # Check the name.
    name = name.to_sym
    # Look for construct to make public.
    # Maybe it is an inner signals.
    inner = self.get_inner(name)
    if inner then
        # Yes set it as export.
        @exports[name] = inner
        return
    end
    # No, maybe it is an instance.
    instance = self.get_systemI(name)
    if instance then
        # Yes, set it as export.
        @exports[name] = instance
        return
    end
    # No, error.
    raise AnyError, "Invalid name for export: #{name}"
end

#add_groupI(name, *instances) ⇒ Object

Adds a group of system +instances+ named +name+.



839
840
841
842
843
844
845
846
847
848
849
850
851
 
# File 'lib/HDLRuby/hruby_high.rb', line 839

def add_groupI(name, *instances)
    # Ensure name is a symbol and is not already used for another
    # group.
    name = name.to_sym
    if @groupIs.key?(name)
        raise AnyError,
              "Group of system instances named #{name} already exist."
    end
    # Add the group.
    @groupIs[name.to_sym] = instances
    # Sets the parent of the instances.
    instances.each { |instance| instance.parent = self }
end

#add_inout(signal) ⇒ Object

Adds inout +signal+ in the current system.



976
977
978
 
# File 'lib/HDLRuby/hruby_high.rb', line 976

def add_inout(signal)
    self.parent.add_inout(signal)
end

#add_input(signal) ⇒ Object

Adds input +signal+ in the current system.



966
967
968
 
# File 'lib/HDLRuby/hruby_high.rb', line 966

def add_input(signal)
    self.parent.add_input(signal)
end

#add_output(signal) ⇒ Object

Adds output +signal+ in the current system.



971
972
973
 
# File 'lib/HDLRuby/hruby_high.rb', line 971

def add_output(signal)
    self.parent.add_output(signal)
end

#as(system) ⇒ Object

Casts as an included +system+.



1229
1230
1231
1232
1233
1234
 
# File 'lib/HDLRuby/hruby_high.rb', line 1229

def as(system)
    # puts "as with name: #{system.name}"
    system = system.name if system.respond_to?(:name)
    # puts "includes are: #{@includes.keys}"
    return @includes[system].namespace
end

#build(&ruby_block) ⇒ Object

Build the scope by executing +ruby_block+.

NOTE: used when the scope is not the top of a system.



935
936
937
938
939
940
941
942
 
# File 'lib/HDLRuby/hruby_high.rb', line 935

def build(&ruby_block)
    # Set the namespace for buidling the scope.
    High.space_push(@namespace)
    # Build the scope.
    @return_value = High.top_user.instance_eval(&ruby_block)
    High.space_pop
    @return_value
end

#build_top(base, *args) ⇒ Object

Builds the scope using +base+ as model scope with possible arguments +args+.

NOTE: Used by the instantiation procedure of a system.



949
950
951
952
953
954
955
956
957
958
959
960
 
# File 'lib/HDLRuby/hruby_high.rb', line 949

def build_top(base,*args)
    # Fills its namespace with the content of the base scope
    # (this latter may already contains access points if it has been
    #  opended for extension previously).
    @namespace.concat_namespace(base.namespace)
    High.space_push(@namespace)
    # Execute the instantiation block
    base.parent.each_instance_proc do |instance_proc|
        @return_value = High.top_user.instance_exec(*args,&instance_proc)
    end
    High.space_pop
end

#code(*content, &ruby_block) ⇒ Object

Declares a non-HDLRuby set of code chunks described by +content+ and completed from +ruby_block+ execution result. NOTE: content includes the events to activate the code on and a description of the code as a hash assotiating names to code text.



1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
 
# File 'lib/HDLRuby/hruby_high.rb', line 1037

def code(*content, &ruby_block)
    # Process the content.
    # Separate events from code chunks descriptions.
    events, chunks = content.partition {|elem| elem.is_a?(Event) }
    # Generates a large hash from the code.
    chunks = chunks.reduce(:merge)
    # Adds the result of the ruby block if any.
    if ruby_block then
        chunks.merge(HDLRuby::High.top_user.instance_eval(&ruby_block))
    end
    # Create the chunk objects.
    chunks = chunks.each.map do |name,content|
        content = [*content]
        # Process the lumps
        content.map! do |lump|
            lump.respond_to?(:to_expr) ? lump.to_expr : lump
        end
        Chunk.new(name,*content)
    end
    # Create the code object.
    res = Code.new
    # Adds the events.
    events.each(&res.method(:add_event))
    # Adds the chunks.
    chunks.each(&res.method(:add_chunk))
    # Adds the resulting code to the current scope.
    HDLRuby::High.top_user.add_code(res)
    # Return the resulting code
    return res
end

#cur_system ⇒ Object

Gets the current system.



1238
1239
1240
 
# File 'lib/HDLRuby/hruby_high.rb', line 1238

def cur_system
    return HDLRuby::High.cur_system
end

#each_export(&ruby_block) ⇒ Object

Iterates over the exported constructs.

Returns an enumerator if no ruby block is given.



899
900
901
902
903
904
905
906
 
# File 'lib/HDLRuby/hruby_high.rb', line 899

def each_export(&ruby_block)
    # No ruby block? Return an enumerator.
    return to_enum(:each_export) unless ruby_block
    # A block? Apply it on each input signal instance.
    @exports.each_value(&ruby_block)
    # And apply on the sub scopes if any.
    @scopes.each {|scope| scope.each_export(&ruby_block) }
end

#each_groupI(&ruby_block) ⇒ Object

Iterates over the group of system instances.

Returns an enumerator if no ruby block is given.



863
864
865
866
867
868
 
# File 'lib/HDLRuby/hruby_high.rb', line 863

def each_groupI(&ruby_block)
    # No ruby block? Return an enumerator.
    return to_enum(:each_groupI) unless ruby_block
    # A block? Apply it on each input signal instance.
    @groupIs.each(&ruby_block)
end

#each_included(&ruby_block) ⇒ Object

Iterates over the included systems.



909
910
911
912
913
914
915
916
 
# File 'lib/HDLRuby/hruby_high.rb', line 909

def each_included(&ruby_block)
    # No ruby block? Return an enumerator.
    return to_enum(:each_included) unless ruby_block
    # A block? Apply it on each included system.
    @includes.each_value(&ruby_block)
    # And apply on the sub scopes if any.
    @scopes.each {|scope| scope.each_included(&ruby_block) }
end

#export(*names) ⇒ Object

Sets the constructs corresponding to +names+ as exports.



1184
1185
1186
 
# File 'lib/HDLRuby/hruby_high.rb', line 1184

def export(*names)
    names.each {|name| self.add_export(name) }
end

#fill_low(scopeL) ⇒ Object

Fills a low level scope with self's contents.

NOTE: name conflicts are treated in the current NameStack state.



1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
 
# File 'lib/HDLRuby/hruby_high.rb', line 1247

def fill_low(scopeL)
    # Adds the content of its included systems.
    @includes.each_value {|system| system.scope.fill_low(scopeL) }
    # Adds the declared local system types.
    # NOTE: in the current version of HDLRuby::High, there should not
    # be any of them (only eigen systems are real system types).
    self.each_systemT { |systemT| scopeL.add_systemT(systemT.to_low) }
    # Adds the local types.
    self.each_type { |type| scopeL.add_type(type.to_low) }
    # Adds the inner scopes.
    self.each_scope { |scope| scopeL.add_scope(scope.to_low) }
    # Adds the inner signals.
    self.each_inner { |inner| scopeL.add_inner(inner.to_low) }
    # Adds the instances.
    # Single ones.
    self.each_systemI do |systemI|
        # puts "Filling with systemI=#{systemI.name}"
        systemI_low = scopeL.add_systemI(systemI.to_low)
        # Also add the eigen system to the list of local systems.
        scopeL.add_systemT(systemI_low.systemT)
    end
    # Grouped ones.
    self.each_groupI do |name,systemIs|
        systemIs.each.with_index { |systemI,i|
            # Sets the name of the system instance
            # (required for conversion of further accesses).
            # puts "systemI.respond_to?=#{systemI.respond_to?(:name=)}"
            systemI.name = name.to_s + "[#{i}]"
            # And convert it to low
            systemI_low = scopeL.add_systemI(systemI.to_low())
            # Also add the eigen system to the list of local systems.
            scopeL.add_systemT(systemI_low.systemT)
        }
    end
    # Adds the code chunks.
    self.each_code { |code| scopeL.add_code(code.to_low) }
    # Adds the connections.
    self.each_connection { |connection|
        # puts "connection=#{connection}"
        scopeL.add_connection(connection.to_low)
    }
    # Adds the behaviors.
    self.each_behavior { |behavior|
        scopeL.add_behavior(behavior.to_low)
    }
end

#get_groupI(name) ⇒ Object

Access a group of system instances by +name+.

NOTE: the result is a copy of the group for avoiding side effects.



856
857
858
 
# File 'lib/HDLRuby/hruby_high.rb', line 856

def get_groupI(name)
    return @groupIs[name.to_sym].clone
end

#hcase(value) ⇒ Object

Creates a new case statement with a +value+ used for deciding which block to execute.

NOTE:

  • the when part is defined through the hwhen method.
  • a new behavior is created to enclose the hcase.


1161
1162
1163
1164
1165
 
# File 'lib/HDLRuby/hruby_high.rb', line 1161

def hcase(value)
    self.par do
        hcase(value)
    end
end

#helse(mode = nil, &ruby_block) ⇒ Object

Sets the block executed when the condition is not met to the block in +mode+ generated by the execution of +ruby_block+.

Can only be used once.

NOTE: added to the hif of the last behavior.



1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
 
# File 'lib/HDLRuby/hruby_high.rb', line 1130

def helse(mode = nil, &ruby_block)
    # There is a ruby_block: the helse is assumed to be with
    # the last statement of the last behavior.
    statement = self.last_behavior.last_statement
    # Completes the hif or the hcase statement.
    unless statement.is_a?(If) or statement.is_a?(Case) then
        raise AnyError, "Error: helse statement without hif nor hcase (#{statement.class})."
    end
    statement.helse(mode, &ruby_block)
end

#helsif(condition, mode = nil, &ruby_block) ⇒ Object

Sets the condition check when the condition is not met to the block, with a +condition+ that when met lead to the execution of the block in +mode+ generated by the +ruby_block+.



1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
 
# File 'lib/HDLRuby/hruby_high.rb', line 1144

def helsif(condition, mode = nil, &ruby_block)
    # There is a ruby_block: the helse is assumed to be with
    # the last statement of the last behavior.
    statement = self.last_behavior.last_statement
    # Completes the hif statement.
    unless statement.is_a?(If) then
        raise AnyError, "Error: helsif statement without hif (#{statement.class})."
    end
    statement.helsif(condition, mode, &ruby_block)
end

#hif(condition, mode = nil, &ruby_block) ⇒ Object

Creates a new if statement with a +condition+ that when met lead to the execution of the block in +mode+ generated by the +ruby_block+.

NOTE:

  • the else part is defined through the helse method.
  • a behavior is created to enclose the hif.


1118
1119
1120
1121
1122
 
# File 'lib/HDLRuby/hruby_high.rb', line 1118

def hif(condition, mode = nil, &ruby_block)
    self.par do
        hif(condition,mode,&ruby_block)
    end
end

#hwhen(match, mode = nil, &ruby_block) ⇒ Object

Sets the block of a case structure executed when the +match+ is met to the block in +mode+ generated by the execution of +ruby_block+.

Can only be used once.



1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
 
# File 'lib/HDLRuby/hruby_high.rb', line 1171

def hwhen(match, mode = nil, &ruby_block)
    # There is a ruby_block: the helse is assumed to be with
    # the last statement of the last behavior.
    statement = @behaviors.last.last_statement
    # Completes the hcase statement.
    unless statement.is_a?(Case) then
        raise AnyError, "Error: hwhen statement without hcase (#{statement.class})."
    end
    statement.hwhen(match, mode, &ruby_block)
end

#include(system, *args) ⇒ Object

Include a +system+ type with possible +args+ instanciation arguments.



1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
 
# File 'lib/HDLRuby/hruby_high.rb', line 1190

def include(system,*args)
    if @includes.key?(system.name) then
        raise AnyError, "Cannot include twice the same system."
    end
    # puts "Include system=#{system.name}"
    # Save the name of the included system, it will serve as key
    # for looking for the included expanded version.
    include_name = system.name
    # Expand the system to include
    system = system.expand(:"",*args)
    # Add the included system interface to the current one.
    if self.parent.is_a?(SystemT) then
        space = self.namespace
        # Interface signals
        # puts "i_name=#{i_name} @to_includes=#{@to_includes.size}"
        system.each_signal_with_included do |signal|
            # puts "signal=#{signal.name}"
            space.send(:define_singleton_method,signal.name) do
                signal
            end
        end
        # Exported objects
        system.each_export do |export|
            # puts "export=#{export.name}"
            space.send(:define_singleton_method,export.name) do
                export
            end
        end
        # Adds the task to execute on the instance.
        system.each_on_instance do |task|
            self.parent.on_instance(&task)
        end
    end
    # Adds it the list of includeds
    @includes[include_name] = system
    
end

#inout(*names) ⇒ Object

Declares high-level bit inout signals named +names+ in the current system.



1028
1029
1030
 
# File 'lib/HDLRuby/hruby_high.rb', line 1028

def inout(*names)
    self.parent.inout(*names)
end

#input(*names) ⇒ Object

Declares high-level bit input signals named +names+ in the current system.



1016
1017
1018
 
# File 'lib/HDLRuby/hruby_high.rb', line 1016

def input(*names)
    self.parent.input(*names)
end

#make_inouts(type, *names) ⇒ Object

Creates and adds a set of inouts typed +type+ from a list of +names+ in the current system.

NOTE: a name can also be a signal, is which case it is duplicated.



1000
1001
1002
 
# File 'lib/HDLRuby/hruby_high.rb', line 1000

def make_inouts(type, *names)
    self.parent.make_inouts(type,*names)
end

#make_inputs(type, *names) ⇒ Object

Creates and adds a set of inputs typed +type+ from a list of +names+ in the current system.

NOTE: a name can also be a signal, is which case it is duplicated.



984
985
986
 
# File 'lib/HDLRuby/hruby_high.rb', line 984

def make_inputs(type, *names)
    self.parent.make_inputs(type,*names)
end

#make_outputs(type, *names) ⇒ Object

Creates and adds a set of outputs typed +type+ from a list of +names+ in the current system.

NOTE: a name can also be a signal, is which case it is duplicated.



992
993
994
 
# File 'lib/HDLRuby/hruby_high.rb', line 992

def make_outputs(type, *names)
    self.parent.make_outputs(type,*names)
end

#open(&ruby_block) ⇒ Object

Opens for extension.

NOTE: actually executes +ruby_block+ in the context.



922
923
924
925
926
927
928
929
 
# File 'lib/HDLRuby/hruby_high.rb', line 922

def open(&ruby_block)
    High.space_push(@namespace)
    res = High.top_user.instance_eval(&ruby_block)
    High.space_pop
    # Return the result of the execution so that it can be used
    # as an expression
    res
end

#output(*names) ⇒ Object

Declares high-level bit output signals named +names+ in the current system.



1022
1023
1024
 
# File 'lib/HDLRuby/hruby_high.rb', line 1022

def output(*names)
    self.parent.output(*names)
end

#par(*events, &ruby_block) ⇒ Object

Declares a high-level parallel behavior activated on a list of +events+, and built by executing +ruby_block+.



1094
1095
1096
1097
1098
1099
1100
1101
 
# File 'lib/HDLRuby/hruby_high.rb', line 1094

def par(*events, &ruby_block)
    # Preprocess the events.
    events.map! do |event|
        event.respond_to?(:to_event) ? event.to_event : event
    end
    # Create and add the resulting behavior.
    self.add_behavior(Behavior.new(:par,*events,&ruby_block))
end

#seq(*events, &ruby_block) ⇒ Object

Declares a high-level sequential behavior activated on a list of +events+, and built by executing +ruby_block+.



1083
1084
1085
1086
1087
1088
1089
1090
 
# File 'lib/HDLRuby/hruby_high.rb', line 1083

def seq(*events, &ruby_block)
    # Preprocess the events.
    events.map! do |event|
        event.respond_to?(:to_event) ? event.to_event : event
    end
    # Create and add the resulting behavior.
    self.add_behavior(Behavior.new(:seq,*events,&ruby_block))
end

#sub(name = :"", &ruby_block) ⇒ Object

Declares a sub scope with possible +name+ and built from +ruby_block+.



1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
 
# File 'lib/HDLRuby/hruby_high.rb', line 1069

def sub(name = :"", &ruby_block)
    # Creates the new scope.
    scope = Scope.new(name,&ruby_block)
    # puts "new scope=#{scope}"
    # Add it
    self.add_scope(scope)
    # puts "self=#{self}"
    # puts "self scopes=#{self.each_scope.to_a.join(",")}"
    # Use its return value
    return scope.return_value
end

#timed(&ruby_block) ⇒ Object

Declares a high-level timed behavior built by executing +ruby_block+. By default, timed behavior are sequential.



1105
1106
1107
1108
 
# File 'lib/HDLRuby/hruby_high.rb', line 1105

def timed(&ruby_block)
    # Create and add the resulting behavior.
    self.add_behavior(TimeBehavior.new(:seq,&ruby_block))
end

#to_low ⇒ Object

Converts the scope to HDLRuby::Low.



1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
 
# File 'lib/HDLRuby/hruby_high.rb', line 1295

def to_low()
    # Create the resulting low scope.
    # scopeL = HDLRuby::Low::Scope.new()
    scopeL = HDLRuby::Low::Scope.new(self.name)
    # For debugging: set the source high object 
    scopeL.properties[:low2high] = self.hdr_id

    # Push the private namespace for the low generation.
    High.space_push(@namespace)
    # Pushes on the name stack for converting the internals of
    # the system.
    High.names_push
    # Adds the content of the actual system.
    self.fill_low(scopeL)
    # Restores the name stack.
    High.names_pop
    # Restores the namespace stack.
    High.space_pop
    # Return theresulting system.
    return scopeL
end

#to_ref ⇒ Object

Converts to a new reference.



1005
1006
1007
 
# File 'lib/HDLRuby/hruby_high.rb', line 1005

def to_ref
    return RefObject.new(this,self)
end

#to_user ⇒ Object

Converts to a namespace user.



833
834
835
836
 
# File 'lib/HDLRuby/hruby_high.rb', line 833

def to_user
    # Already a user.
    return self
end