1 files changed, 219 insertions, 156 deletions
diff --git a/grc/python/FlowGraph.py b/grc/python/FlowGraph.py
index 1080006cf5..180d605720 100644
--- a/grc/python/FlowGraph.py
+++ b/grc/python/FlowGraph.py
@@ -20,174 +20,237 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 import expr_utils
 from .. base.FlowGraph import FlowGraph as _FlowGraph
 from .. gui.FlowGraph import FlowGraph as _GUIFlowGraph
+from .. base.odict import odict
 import re
 
 _variable_matcher = re.compile('^(variable\w*)$')
 _parameter_matcher = re.compile('^(parameter)$')
 _monitors_searcher = re.compile('(ctrlport_monitor)')
+_bussink_searcher = re.compile('^(bus_sink)$')
+_bussrc_searcher = re.compile('^(bus_source)$')
+_bus_struct_sink_searcher = re.compile('^(bus_structure_sink)$')
+_bus_struct_src_searcher = re.compile('^(bus_structure_source)$')
 
 class FlowGraph(_FlowGraph, _GUIFlowGraph):
 
-	def __init__(self, **kwargs):
-		_FlowGraph.__init__(self, **kwargs)
-		_GUIFlowGraph.__init__(self)
-		self._eval_cache = dict()
+    def __init__(self, **kwargs):
+        _FlowGraph.__init__(self, **kwargs)
+        _GUIFlowGraph.__init__(self)
+        self._eval_cache = dict()
 
-	def _eval(self, code, namespace, namespace_hash):
-		"""
-		Evaluate the code with the given namespace.
-		
-		Args:
-		    code: a string with python code
-		    namespace: a dict representing the namespace
-		    namespace_hash: a unique hash for the namespace
-		
-		Returns:
-		    the resultant object
-		"""
-		if not code: raise Exception, 'Cannot evaluate empty statement.'
-		my_hash = hash(code) ^ namespace_hash
-		#cache if does not exist
-		if not self._eval_cache.has_key(my_hash):
-			self._eval_cache[my_hash] = eval(code, namespace, namespace)
-		#return from cache
-		return self._eval_cache[my_hash]
-
-	def get_io_signaturev(self, direction):
-		"""
-		Get a list of io signatures for this flow graph.
-		
-		Args:
-		    direction: a string of 'in' or 'out'
-		
-		Returns:
-		    a list of dicts with: type, label, vlen, size
-		"""
-		sorted_pads = {
-			'in': self.get_pad_sources(),
-			'out': self.get_pad_sinks(),
-		}[direction]
+    def _eval(self, code, namespace, namespace_hash):
+        """
+        Evaluate the code with the given namespace.
+        
+        Args:
+            code: a string with python code
+            namespace: a dict representing the namespace
+            namespace_hash: a unique hash for the namespace
+        
+        Returns:
+            the resultant object
+        """
+        if not code: raise Exception, 'Cannot evaluate empty statement.'
+        my_hash = hash(code) ^ namespace_hash
+        #cache if does not exist
+        if not self._eval_cache.has_key(my_hash):
+            self._eval_cache[my_hash] = eval(code, namespace, namespace)
+        #return from cache
+        return self._eval_cache[my_hash]
+
+    def get_io_signaturev(self, direction):
+        """
+        Get a list of io signatures for this flow graph.
+        
+        Args:
+            direction: a string of 'in' or 'out'
+        
+        Returns:
+            a list of dicts with: type, label, vlen, size
+        """
+        sorted_pads = {
+            'in': self.get_pad_sources(),
+            'out': self.get_pad_sinks(),
+        }[direction]
         # we only want stream ports
-		sorted_pads = filter(lambda b: b.get_param('type').get_evaluated() != 'message', sorted_pads);
-		#load io signature
-		return [{
-			'label': str(pad.get_param('label').get_evaluated()),
-			'type': str(pad.get_param('type').get_evaluated()),
-			'vlen': str(pad.get_param('vlen').get_evaluated()),
-			'size': pad.get_param('type').get_opt('size'),
-			'optional': bool(pad.get_param('optional').get_evaluated()),
-		} for pad in sorted_pads]
-
-	def get_pad_sources(self):
-		"""
-		Get a list of pad source blocks sorted by id order.
-		
-		Returns:
-		    a list of pad source blocks in this flow graph
-		"""
-		pads = filter(lambda b: b.get_key() == 'pad_source', self.get_enabled_blocks())
-		return sorted(pads, lambda x, y: cmp(x.get_id(), y.get_id()))
-
-	def get_pad_sinks(self):
-		"""
-		Get a list of pad sink blocks sorted by id order.
-		
-		Returns:
-		    a list of pad sink blocks in this flow graph
-		"""
-		pads = filter(lambda b: b.get_key() == 'pad_sink', self.get_enabled_blocks())
-		return sorted(pads, lambda x, y: cmp(x.get_id(), y.get_id()))
-
-	def get_msg_pad_sources(self):
-		ps = self.get_pad_sources();
-		return filter(lambda b: b.get_param('type').get_evaluated() == 'message', ps);
-
-	def get_msg_pad_sinks(self):
-		ps = self.get_pad_sinks();
-		return filter(lambda b: b.get_param('type').get_evaluated() == 'message', ps);
-
-	def get_imports(self):
-		"""
-		Get a set of all import statments in this flow graph namespace.
+        sorted_pads = filter(lambda b: b.get_param('type').get_evaluated() != 'message', sorted_pads);
+        expanded_pads = [];
+        for i in sorted_pads:
+            for j in range(i.get_param('num_streams').get_evaluated()):
+                expanded_pads.append(i);
+        #load io signature
+        return [{
+            'label': str(pad.get_param('label').get_evaluated()),
+            'type': str(pad.get_param('type').get_evaluated()),
+            'vlen': str(pad.get_param('vlen').get_evaluated()),
+            'size': pad.get_param('type').get_opt('size'),
+            'optional': bool(pad.get_param('optional').get_evaluated()),
+        } for pad in expanded_pads]
+
+    def get_pad_sources(self):
+        """
+        Get a list of pad source blocks sorted by id order.
+        
+        Returns:
+            a list of pad source blocks in this flow graph
+        """
+        pads = filter(lambda b: b.get_key() == 'pad_source', self.get_enabled_blocks())
+        return sorted(pads, lambda x, y: cmp(x.get_id(), y.get_id()))
+
+    def get_pad_sinks(self):
+        """
+        Get a list of pad sink blocks sorted by id order.
+        
+        Returns:
+            a list of pad sink blocks in this flow graph
+        """
+        pads = filter(lambda b: b.get_key() == 'pad_sink', self.get_enabled_blocks())
+        return sorted(pads, lambda x, y: cmp(x.get_id(), y.get_id()))
+
+    def get_msg_pad_sources(self):
+        ps = self.get_pad_sources();
+        return filter(lambda b: b.get_param('type').get_evaluated() == 'message', ps);
+
+    def get_msg_pad_sinks(self):
+        ps = self.get_pad_sinks();
+        return filter(lambda b: b.get_param('type').get_evaluated() == 'message', ps);
+
+    def get_imports(self):
+        """
+        Get a set of all import statments in this flow graph namespace.
+        
+        Returns:
+            a set of import statements
+        """
+        imports = sum([block.get_imports() for block in self.get_enabled_blocks()], [])
+        imports = sorted(set(imports))
+        return imports
+
+    def get_variables(self):
+        """
+        Get a list of all variables in this flow graph namespace.
+        Exclude paramterized variables.
+        
+        Returns:
+            a sorted list of variable blocks in order of dependency (indep -> dep)
+        """
+        variables = filter(lambda b: _variable_matcher.match(b.get_key()), self.get_enabled_blocks())
+        return expr_utils.sort_objects(variables, lambda v: v.get_id(), lambda v: v.get_var_make())
+
+    def get_parameters(self):
+        """
+        Get a list of all paramterized variables in this flow graph namespace.
+        
+        Returns:
+            a list of paramterized variables
+        """
+        parameters = filter(lambda b: _parameter_matcher.match(b.get_key()), self.get_enabled_blocks())
+        return parameters
+
+    def get_monitors(self):
+        """
+        Get a list of all ControlPort monitors
+        """
+        monitors = filter(lambda b: _monitors_searcher.search(b.get_key()), self.get_enabled_blocks())
+        return monitors
+
+
+    def get_bussink(self):
+        bussink = filter(lambda b: _bussink_searcher.search(b.get_key()), self.get_enabled_blocks())
 		
-		Returns:
-		    a set of import statements
-		"""
-		imports = sum([block.get_imports() for block in self.get_enabled_blocks()], [])
-		imports = sorted(set(imports))
-		return imports
-
-	def get_variables(self):
-		"""
-		Get a list of all variables in this flow graph namespace.
-		Exclude paramterized variables.
+        for i in bussink:
+            for j in i.get_params():
+                if j.get_name() == 'On/Off' and j.get_value() == 'on':
+                    return True;
+			
+        return False
 		
-		Returns:
-		    a sorted list of variable blocks in order of dependency (indep -> dep)
-		"""
-		variables = filter(lambda b: _variable_matcher.match(b.get_key()), self.get_enabled_blocks())
-		return expr_utils.sort_objects(variables, lambda v: v.get_id(), lambda v: v.get_var_make())
-
-	def get_parameters(self):
-		"""
-		Get a list of all paramterized variables in this flow graph namespace.
 		
-		Returns:
-		    a list of paramterized variables
-		"""
-		parameters = filter(lambda b: _parameter_matcher.match(b.get_key()), self.get_enabled_blocks())
-		return parameters
-
-	def get_monitors(self):
-		"""
-		Get a list of all ControlPort monitors
-		"""
-		monitors = filter(lambda b: _monitors_searcher.search(b.get_key()), self.get_enabled_blocks())
-                return monitors
-
-	def rewrite(self):
-		"""
-		Flag the namespace to be renewed.
-		"""
-		self._renew_eval_ns = True
-		_FlowGraph.rewrite(self)
-
-	def evaluate(self, expr):
-		"""
-		Evaluate the expression.
+
+    def get_bussrc(self):
+        bussrc = filter(lambda b: _bussrc_searcher.search(b.get_key()), self.get_enabled_blocks())
+
+        for i in bussrc:
+            for j in i.get_params():
+                if j.get_name() == 'On/Off' and j.get_value() == 'on':
+                    return True;
+			
+        return False
+
+    def get_bus_structure_sink(self):
+        bussink = filter(lambda b: _bus_struct_sink_searcher.search(b.get_key()), self.get_enabled_blocks())
+			
+        return bussink
+
+    def get_bus_structure_src(self):
+        bussrc = filter(lambda b: _bus_struct_src_searcher.search(b.get_key()), self.get_enabled_blocks())
 		
-		Args:
-		    expr: the string expression
-		@throw Exception bad expression
+        return bussrc
 		
-		Returns:
-		    the evaluated data
-		"""
-		if self._renew_eval_ns:
-			self._renew_eval_ns = False
-			#reload namespace
-			n = dict()
-			#load imports
-			for imp in self.get_imports():
-				try: exec imp in n
-				except: pass
-			#load parameters
-			np = dict()
-			for parameter in self.get_parameters():
-				try:
-					e = eval(parameter.get_param('value').to_code(), n, n)
-					np[parameter.get_id()] = e
-				except: pass
-			n.update(np) #merge param namespace
-			#load variables
-			for variable in self.get_variables():
-				try:
-					e = eval(variable.get_param('value').to_code(), n, n)
-					n[variable.get_id()] = e
-				except: pass
-			#make namespace public
-			self.n = n
-			self.n_hash = hash(str(n))
-		#evaluate
-		e = self._eval(expr, self.n, self.n_hash)
-		return e
+
+    def rewrite(self):
+        """
+        Flag the namespace to be renewed.
+        """
+        def reconnect_bus_blocks():
+            for block in self.get_blocks():
+                
+                if 'bus' in map(lambda a: a.get_type(), block.get_sources_gui()):
+                    
+                    
+                    for i in range(len(block.get_sources_gui())):
+                        if len(block.get_sources_gui()[i].get_connections()) > 0:
+                            source = block.get_sources_gui()[i]
+                            sink = []
+                            
+                            for j in range(len(source.get_connections())):
+                                sink.append(source.get_connections()[j].get_sink());
+                        
+                                        
+                            for elt in source.get_connections():
+                                self.remove_element(elt);
+                            for j in sink:
+                                self.connect(source, j);
+        self._renew_eval_ns = True
+        _FlowGraph.rewrite(self);
+        reconnect_bus_blocks();
+
+    def evaluate(self, expr):
+        """
+        Evaluate the expression.
+        
+        Args:
+            expr: the string expression
+        @throw Exception bad expression
+        
+        Returns:
+            the evaluated data
+        """
+        if self._renew_eval_ns:
+            self._renew_eval_ns = False
+            #reload namespace
+            n = dict()
+            #load imports
+            for imp in self.get_imports():
+                try: exec imp in n
+                except: pass
+            #load parameters
+            np = dict()
+            for parameter in self.get_parameters():
+                try:
+                    e = eval(parameter.get_param('value').to_code(), n, n)
+                    np[parameter.get_id()] = e
+                except: pass
+            n.update(np) #merge param namespace
+            #load variables
+            for variable in self.get_variables():
+                try:
+                    e = eval(variable.get_param('value').to_code(), n, n)
+                    n[variable.get_id()] = e
+                except: pass
+            #make namespace public
+            self.n = n
+            self.n_hash = hash(str(n))
+        #evaluate
+        e = self._eval(expr, self.n, self.n_hash)
+        return e