Initial commit of script to generate (and eventually update) a static test configuration file for the gfortran tests.

Author: Tarun Prabhu

Fortran/gfortran/utils/update-test-config.py

@@ -0,0 +1,224 @@
+#!/usr/bin/env python3
+
+import chardet
+import os
+import re
+
+# Class representing a single test.
+class Test:
+    UNKNOWN = 0
+    PREPROCESS = 1
+    COMPILE = 2
+    LINK = 3
+    RUN = 4
+
+    # int, [os.path], [str], [str], bool
+    def __init__(self, kind, sources, options, targets, expected_fail):
+        self.kind = kind
+
+        # The sources needed by the test. This will have at least one element.
+        # The first element of the list will be the "main" file. The rest must
+        # be in the order in which they should be compiled. The elements will be
+        # the basename's of the file because all dependent files are in the
+        # same directory, so there is no need to have the full (or relative)
+        # path.
+        self.sources = sources
+
+        # The command-line options needed by the test.
+        self.options = options
+
+        # The optional targets for the test.
+        self.target = targets
+
+        # Whether the test is expected to fail.
+        self.expected_fail = expected_fail
+
+        # Whether to use separate compilation for this test (is this even
+        # necessary?)
+        self.separate_compilation = False
+
+    def __str__(self):
+        m = ['', 'PREPROCESS', 'COMPILE', 'LINK', 'RUN']
+        return '{}: {}'.format(m[self.kind], self.sources)
+
+# Checks if the basename of a file has a Fortran extension.
+re_fortran = re.compile('^.+[.][Ff].*$')
+
+# Checks if the line has a preprocess annotation.
+re_preprocess = re.compile('[{][ ]*dg-do preprocess[ ]*[}]')
+
+# Checks if the line has a compile annotation.
+# FIXME: Add match for target
+re_compile = re.compile('[{][ ]*dg-do[ ]*compile[ ]*(.*)[}]')
+
+# Checks if the line has a link annotation.
+re_link = re.compile('[{][ ]*dg-do[ ]*link[ ]+(.*)[}]')
+
+# Checks if the line has a run annotation or lto-run annotation.
+# FIXME: Add match for target
+re_run = re.compile('[{][ ]*dg-(lto-)?do[ ]*run[ ]+(.*)[}]')
+
+# Checks if the line has an additional-sources annotation.
+re_sources = re.compile('[{][ ]*dg-additional-sources[ ]*["]?([^"])["]?[ ]*[}]')
+
+# Checks if the line has a dg-compile-aux-modules annotation.
+re_aux_modules = re.compile(
+    '[{][ ]*dg-compile-aux-modules[ ]*["]?([^"])["]?[}]'
+)
+
+# Checks if the line has an options or additional-options annotation. The
+# option may have an optional target.
+re_options = re.compile(
+    '[{][ ]*dg-(additional-)?options[ ]*["]?([^\"]*)["]?[ ]*[}][ ]*([{][ ]*target[ ]*(.+)?[ ][}])?'
+)
+
+# Checks if the line has a shouldfail annotation.
+re_shouldfail = re.compile('[{][ ]*dg-shouldfail[ ]*.*[}]')
+
+# Checks if the line has a dg-error annotation.
+# TODO: There may be
+re_error = re.compile('[{][ ]*dg-error[ ]*[}]')
+
+# Get the n-th level ancestor of the given file. The 1st level ancestor is
+# the directory containing the file. The 2nd level ancestor is the parent of
+# that directory and so on.
+# os.path, int -> os.path
+def get_ancestor(f, n):
+    anc = f
+    for _ in range(0, n):
+        anc = os.path.dirname(anc)
+    return anc
+
+# Get the encoding of the file.
+# os.path -> str
+def get_encoding(filepath):
+    with open(filepath, 'rb') as f:
+        return chardet.detect(f.read())['encoding']
+    return None
+
+# Get the lines in the file.
+# os.path -> [str]
+def get_lines(filepath):
+    lines = []
+    try:
+        with open(filepath, 'r', encoding = get_encoding(filepath)) as f:
+            lines = f.readlines()
+    except:
+        print('WARNING: Could not open file:', os.path.basename(filepath))
+    finally:
+        return lines
+
+# Collect the subdirectories of the gfortran directory which may contain tests.
+# os.path -> [os.path]
+def get_subdirs(gfortran):
+    regression = os.path.join(gfortran, 'regression')
+    torture = os.path.join(gfortran, 'torture')
+
+    subdirs = [regression]
+    for root, dirs, _ in os.walk(regression):
+        subdirs.extend([os.path.join(root, d) for d in dirs])
+    subdirs.append(torture)
+    for root, dirs, _ in os.walk(torture):
+        subdirs.extend([os.path.join(root, d) for d in dirs])
+    return subdirs
+
+# Try to match the line with the regex. If the line matches, add the match
+# object to the MOUT list and return True. Otherwise, leave the MOUT list
+# unchanged and return False.
+# re, str, [re.MATCH] -> bool
+def try_match(regex, line, mout):
+    m = regex.search(line)
+    if m:
+        mout.append(m)
+        return True
+    return False
+
+# () -> int
+def main():
+    root = get_ancestor(os.path.realpath(__file__), 4)
+    gfortran = os.path.join(root, 'Fortran', 'gfortran')
+    subdirs = get_subdirs(gfortran)
+
+    for subdir in subdirs:
+        print(subdir)
+        files = []
+        for e in os.scandir(subdir):
+            if e.is_file() and re_fortran.match(e.name):
+                files.append(e.path)
+
+        # Find all the files that are dependencies of some file that is the
+        # main file in a test.
+        dependencies = set([])
+        for filename in files:
+            for l in get_lines(filename):
+                mout = []
+                if try_match(re_sources, l, mout):
+                    m = mout[0]
+                    d = os.path.dirname(filename)
+                    for src in m[1].split():
+                        dependencies.add(os.path.join(d, src))
+        print(dependencies)
+        return 0
+
+        tests = []
+        for f in files:
+            if f in dependencies:
+                continue
+            filename = os.path.basename(f)
+            kind = None
+            sources = [filename]
+            options = []
+            targets = []
+            expect_error = False
+
+            for l in get_lines(f):
+                mout = []
+                if try_match(re_preprocess, l, mout):
+                    kind = Test.PREPROCESS
+                elif try_match(re_compile, l, mout):
+                    kind = Test.COMPILE
+                    # TODO: Handle the optional target.
+                elif try_match(re_link, l, mout):
+                    kind = Test.LINK
+                    # TODO: Assume that this has an optional target.
+                elif try_match(re_run, l, mout):
+                    kind = Test.RUN
+                    # TODO: Handle the optional target.
+                elif try_match(re_shouldfail, l, mout) or \
+                     try_match(re_error, l, mout):
+                    expect_error = True
+                elif try_match(re_sources, l, mout) or \
+                     try_match(re_aux_modules, l, mout):
+                    m = mout[0]
+                    sources.extend(m[1].split())
+                elif try_match(re_options, l, mout):
+                    m = mout[0]
+                    options.extend(m[2].split())
+                    # TODO: Handle the optional target.
+            if kind:
+                test = Test(kind, sources, options, targets, expect_error)
+                tests.append(test)
+            elif len(sources) > 1:
+                print(
+                    '  WARNING: Additional sources without action annotation:',
+                    filename
+                )
+            elif len(options) > 1:
+                print(
+                    '  WARNING: Compile options without action annotation:',
+                    filename
+                )
+            elif expect_error:
+                print(
+                    '  WARNING: Expect error set without action annotation',
+                    filename
+                )
+            else:
+                pass
+                # print('  WARNING: No action annotation:', filename)
+        for t in tests:
+            print(str(t))
+        # print(' ', len(tests))
+
+if __name__ == '__main__':
+    exit(main())