Factorize the Ada file regular expression and turn free functions into class-methods

Do this to share as much logic as possible between test drivers.

Author: HugoGGuerrier

testsuite/drivers/base_driver.py

@@ -20,29 +20,6 @@
 )
 
 
-_flag_pattern = re.compile(r"--\s*FLAG\s*(\((\d+)\))?\s*(.*)")
-_noflag_pattern = re.compile(r"--\s*NOFLAG")
-_ada_source_encodings = ['utf-8', 'iso-8859-1']
-
-
-def read_ada_file(file_name: str) -> tuple[list[str], str]:
-    """
-    Read the given Ada file with an automatic encoding detection strategy.
-    Returns a tuple containing the lines of the file and its encoding.
-
-    :param file_name: The Ada file to read.
-    """
-    with open(file_name, mode='rb') as ada_file:
-        ada_bytes = ada_file.read()
-        for encoding in _ada_source_encodings:
-            try:
-                lines = ada_bytes.decode(encoding).split('\n')
-                lines = lines[:-1] if not lines[-1] else lines
-                return (lines, encoding)
-            except ValueError as _:
-                pass
-
-
 class Flags:
     """
     Represents the flags in the source files.
@@ -125,6 +102,11 @@ class BaseDriver(DiffTestDriver):
     Common code for all test drivers.
     """
 
+    flag_pattern = re.compile(r"--\s*FLAG\s*(\((\d+)\))?\s*(.*)")
+    noflag_pattern = re.compile(r"--\s*NOFLAG")
+    ada_file_pattern = r"[a-zA-Z][a-zA-Z0-9_\.\-]*\.(adb|ads|ada|ada_spec)"
+    ada_source_encodings = ['utf-8', 'iso-8859-1']
+
     perf_supported = False
     flag_checking_supported = False
 
@@ -398,13 +380,13 @@ def count_source_flags(self) -> tuple[Flags, Flags]:
         # For each file, read it and parse the annotations
         for ada_file_name in ada_sources:
             base_name = P.basename(ada_file_name)
-            ada_lines, _ = read_ada_file(ada_file_name)
+            ada_lines, _ = self.read_ada_file(ada_file_name)
             for line_num, line in enumerate(ada_lines, 1):
-                flag_search = _flag_pattern.search(line)
+                flag_search = self.flag_pattern.search(line)
                 if flag_search:
                     count = int(flag_search.group(2)) if flag_search.group(2) else 1
                     flag_annotations.add_flags(base_name, [line_num] * count)
-                elif _noflag_pattern.search(line):
+                elif self.noflag_pattern.search(line):
                     noflag_annotations.add_flag(base_name, line_num)
 
         # Return the tuple result
@@ -508,7 +490,7 @@ def add_missing_flags(self, missing_flags: Flags) -> None:
             if missing_flags.has_flags(base_name):
                 # Get the file lines and encoding
                 file_lines = []
-                ada_lines, file_encoding = read_ada_file(ada_file_name)
+                ada_lines, file_encoding = self.read_ada_file(ada_file_name)
                 file_lines = [line.rstrip() for line in ada_lines]
 
                 # For each missing flag we add in in the file lines
@@ -520,7 +502,7 @@ def add_missing_flags(self, missing_flags: Flags) -> None:
                     code, comment = split[0], split[1].strip() if len(split) == 2 else ""
 
                     # If there is already a "FLAG" annotation we have to count the number of it then rewrite it
-                    flag_search = _flag_pattern.search(f"-- {comment}")
+                    flag_search = self.flag_pattern.search(f"-- {comment}")
                     if flag_search:
                         count += int(flag_search.group(2) if flag_search.group(2) else 1)
                         comment = flag_search.group(3)
@@ -536,6 +518,24 @@ def add_missing_flags(self, missing_flags: Flags) -> None:
                     for line in file_lines:
                         print(line, file=ada_file)
 
+    @classmethod
+    def read_ada_file(cls, file_name: str) -> tuple[list[str], str]:
+        """
+        Read the given Ada file with an automatic encoding detection strategy.
+        Returns a tuple containing the lines of the file and its encoding.
+
+        :param file_name: The Ada file to read.
+        """
+        with open(file_name, mode='rb') as ada_file:
+            ada_bytes = ada_file.read()
+            for encoding in cls.ada_source_encodings:
+                try:
+                    lines = ada_bytes.decode(encoding).split('\n')
+                    lines = lines[:-1] if not lines[-1] else lines
+                    return (lines, encoding)
+                except ValueError as _:
+                    pass
+
     def _define_lkql_executables(self) -> None:
         # If the mode is JIT
         if self.env.options.mode == "jit":

testsuite/drivers/checker_driver.py

@@ -28,6 +28,10 @@ class CheckerDriver(BaseDriver):
     perf_supported = True
     flag_checking_supported = True
 
+    _flag_line_pattern = re.compile(
+        rf"^({BaseDriver.ada_file_pattern}):(\d+):\d+: rule violation: .*$"
+    )
+
     def run(self) -> None:
         args = []
 
@@ -93,17 +97,12 @@ def run(self) -> None:
                             self.output += f.read()
 
     def parse_flagged_lines(self, output: str) -> Flags:
-        # Compile the pattern to match a checker output
-        pattern = re.compile(
-            r"^([a-zA-Z][a-zA-Z0-9_\-]*\.(adb|ads)):(\d+):\d+: rule violation: .*$"
-        )
-
         # Prepare the result
         res = Flags()
 
         # For each line of the output search the groups in the line
         for line in output.splitlines():
-            search_result = pattern.search(line)
+            search_result = self._flag_line_pattern.search(line)
             if search_result is not None:
                 (file, _, line_num) = search_result.groups()
                 res.add_flag(file, int(line_num))

testsuite/drivers/gnatcheck_driver.py

@@ -6,79 +6,6 @@
 from drivers.base_driver import BaseDriver, Flags
 
 
-# --- GNATcheck output parsing functions
-
-_flag_line_pattern = re.compile(
-    r"^([a-zA-Z][a-zA-Z0-9_\.\-]*\.(adb|ads|ada|ada_spec)):(\d+):\d+: .*$"
-)
-
-def _parse_full(output: str) -> Flags:
-    """
-    Parse the full formatted gnatcheck output.
-    """
-    # Prepare the result
-    res = Flags()
-
-    # Parse the gnatcheck full output
-    is_parsing = False
-    for line in output.splitlines():
-        if not is_parsing:
-            is_parsing = "2. Exempted Coding Standard Violations" in line
-        else:
-            search_result = _flag_line_pattern.search(line)
-            if search_result is not None:
-                (file, _, line_num) = search_result.groups()
-                res.add_flag(file, int(line_num))
-            is_parsing = "5. Language violations" not in line
-
-    # Return the result
-    return res
-
-def _parse_short_and_brief(output: str) -> Flags:
-    """
-    Parse the short formatted gnatcheck output.
-    """
-    # Prepare the result
-    res = Flags()
-
-    # Parse the output
-    for line in output.splitlines():
-        search_result = _flag_line_pattern.search(line)
-        if search_result is not None:
-            (file, _, line_num) = search_result.groups()
-            res.add_flag(file, int(line_num))
-
-    # Return the result
-    return res
-
-def _parse_xml(output: str) -> Flags:
-    """
-    Parse the xml formatted gnatcheck output.
-    """
-    # Prepare the result
-    res = Flags()
-
-    # Parse the xml result
-    xml_tree = ET.fromstring(output)
-    violations = xml_tree.find("violations")
-
-    # If the "violations" tag exists in the output, parse it as a full XML output
-    if violations is not None:
-        for violation in violations:
-            file, line_num = violation.attrib["file"], int(violation.attrib["line"])
-            res.add_flag(file, line_num)
-
-    # Else the ouput is a brief XML one
-    else:
-        for elem in xml_tree.findall("*"):
-            if elem.tag in ("violation", "exemption-problem", "exempted-violation"):
-                file, line_num = elem.attrib["file"], int(elem.attrib["line"])
-                res.add_flag(file, line_num)
-
-    # Return the result
-    return res
-
-
 class GnatcheckDriver(BaseDriver):
     """
     This driver runs gnatcheck with the given arguments and compares the output
@@ -191,12 +118,88 @@ class GnatcheckDriver(BaseDriver):
         "gnatkp": "gnatkp"
     }
     output_formats = set(['brief', 'full', 'short', 'xml'])
-    parsers = {
-        'full': _parse_full,
-        'short': _parse_short_and_brief,
-        'brief': _parse_short_and_brief,
-        'xml': _parse_xml
-    }
+
+    flag_line_pattern = re.compile(
+        rf"^({BaseDriver.ada_file_pattern}):(\d+):\d+: (rule violation|warning|error): .*$"
+    )
+
+    @classmethod
+    def _parse_full(cls, output: str) -> Flags:
+        """
+        Parse the full formatted GNATcheck output.
+        """
+        # Prepare the result
+        res = Flags()
+
+        # Parse the gnatcheck full output
+        is_parsing = False
+        for line in output.splitlines():
+            if not is_parsing:
+                is_parsing = "2. Exempted Coding Standard Violations" in line
+            else:
+                search_result = cls.flag_line_pattern.search(line)
+                if search_result is not None:
+                    (file, _, line_num) = search_result.groups()
+                    res.add_flag(file, int(line_num))
+                is_parsing = "5. Language violations" not in line
+
+        # Return the result
+        return res
+
+    @classmethod
+    def _parse_short_and_brief(cls, output: str) -> Flags:
+        """
+        Parse the short formatted GNATcheck output.
+        """
+        # Prepare the result
+        res = Flags()
+
+        # Parse the output
+        for line in output.splitlines():
+            search_result = cls.flag_line_pattern.search(line)
+            if search_result is not None:
+                (file, _, line_num) = search_result.groups()
+                res.add_flag(file, int(line_num))
+
+        # Return the result
+        return res
+
+    @classmethod
+    def _parse_xml(cls, output: str) -> Flags:
+        """
+        Parse the XML formatted GNATcheck output.
+        """
+        # Prepare the result
+        res = Flags()
+
+        # Parse the xml result
+        xml_tree = ET.fromstring(output)
+        violations = xml_tree.find("violations")
+
+        # If the "violations" tag exists in the output, parse it as a full XML output
+        if violations is not None:
+            for violation in violations:
+                file, line_num = violation.attrib["file"], int(violation.attrib["line"])
+                res.add_flag(file, line_num)
+
+        # Else the ouput is a brief XML one
+        else:
+            for elem in xml_tree.findall("*"):
+                if elem.tag in ("violation", "exemption-problem", "exempted-violation"):
+                    file, line_num = elem.attrib["file"], int(elem.attrib["line"])
+                    res.add_flag(file, line_num)
+
+        # Return the result
+        return res
+
+    @classmethod
+    def parsers(cls):
+        return {
+            'full': cls._parse_full,
+            'short': cls._parse_short_and_brief,
+            'brief': cls._parse_short_and_brief,
+            'xml': cls._parse_xml
+        }
 
     @property
     def default_process_timeout(self):
@@ -525,4 +528,4 @@ def run_one_test(test_data: dict[str, any]) -> None:
 
     def parse_flagged_lines(self, output: str, format: str) -> Flags:
         assert format in self.output_formats
-        return self.parsers[format](output)
+        return self.parsers()[format](output)