Issue #85 ignoring function generics

Author: kraigher

vunit/test/unit/test_vhdl_parser.py

@@ -68,6 +68,26 @@ def test_parsing_entity_with_type_generic(self):
         self.assertEqual(entity.generics[0].identifier, 'type_g')
         self.assertEqual(entity.generics[0].subtype_indication.type_mark, 'integer')
 
+    def test_parsing_entity_with_function_generic(self):
+        entity = self.parse_single_entity("""\
+entity ent is
+  generic (
+    function f(a : integer; b : integer) return integer;
+    function_g : boolean;
+    impure function if(a : integer; b : integer) return integer;
+    procedure_g : boolean;
+    procedure p(a : integer; b : integer)
+    );
+end entity;
+""")
+        self.assertEqual(entity.identifier, "ent")
+        self.assertEqual(entity.ports, [])
+        self.assertEqual(len(entity.generics), 2)
+        self.assertEqual(entity.generics[0].identifier, 'function_g')
+        self.assertEqual(entity.generics[0].subtype_indication.type_mark, 'boolean')
+        self.assertEqual(entity.generics[1].identifier, 'procedure_g')
+        self.assertEqual(entity.generics[1].subtype_indication.type_mark, 'boolean')
+
     def test_getting_entities_from_design_file(self):
         design_file = VHDLDesignFile.parse("""
 entity entity1 is

vunit/vhdl_parser.py

@@ -396,8 +396,34 @@ def _find_port_clause(cls, code):
                     code[match.start(): match.end() + closing_pos + match_semicolon.end()])
         return []
 
+    @staticmethod
+    def _split_not_in_par(string, sep):
+        """
+        Split string at all occurences of sep but not inside of a parenthesis
+        """
+        result = []
+        count = 0
+        split = []
+        for char in string:
+            if char == '(':
+                count += 1
+            elif char == ')':
+                count -= 1
+
+            if char == sep and count == 0:
+                result.append("".join(split))
+                split = []
+            else:
+                split.append(char)
+
+        if len(split) > 0:
+            result.append("".join(split))
+
+        return result
+
     _package_generic_re = re.compile(r"\s*package\s+", re.MULTILINE | re.IGNORECASE)
     _type_generic_re = re.compile(r"\s*type\s+", re.MULTILINE | re.IGNORECASE)
+    _function_generic_re = re.compile(r"\s*(impure\s+)?(function|procedure)\s+", re.MULTILINE | re.IGNORECASE)
 
     @classmethod
     def _parse_generic_clause(cls, code):
@@ -408,7 +434,7 @@ def _parse_generic_clause(cls, code):
         generic_list_string = code[code.find('(') + 1: code.rfind(')')]
 
         # Split the interface elements
-        interface_elements = generic_list_string.split(';')
+        interface_elements = cls._split_not_in_par(generic_list_string, ';')
 
         generic_list = []
         # Add interface elements to the generic list
@@ -422,6 +448,10 @@ def _parse_generic_clause(cls, code):
                 # Ignore type generics
                 continue
 
+            if cls._function_generic_re.match(interface_element) is not None:
+                # Ignore function generics
+                continue
+
             generic_list.append(VHDLInterfaceElement.parse(interface_element))
 
         return generic_list