This is the mail archive of the gcc@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: Transformation of contrib/check_GNU_style.sh to a python script


On 05/19/2017 03:47 PM, Martin Liška wrote:
+if __name__ == '__main__':
+    if len(sys.argv) > 1:
+        main()
+    else:
+        unittest.main()

Hi,

when specifying no arguments to the script, I see:
...
$ ./contrib/check_GNU_style.py
.
----------------------------------------------------------------------
Ran 1 test in 0.000s

OK
...
In other words, the unit tests are run.

I was expecting some form of help message.


Attached patch splits off a lib file from the script. When running the lib file as a script, we run the unit tests. When running the script without args, we see:
...
$ ./contrib/check_GNU_style.py
usage: check_GNU_style.py [-h] [-f {stdio,quickfix}] file
check_GNU_style.py: error: the following arguments are required: file
...

OK?

Thanks,
- Tom
check_GNU_style.py: print usage if no file specified

2017-05-22  Tom de Vries  <tom@codesourcery.com>

	* check_GNU_style_lib.py: New file, factored out of ...
	* check_GNU_style.py: ... here.  Call main unconditionally.

---
 contrib/check_GNU_style.py     | 249 +-------------------------------------
 contrib/check_GNU_style_lib.py | 267 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 270 insertions(+), 246 deletions(-)

diff --git a/contrib/check_GNU_style.py b/contrib/check_GNU_style.py
index b236e93..6970ddf 100755
--- a/contrib/check_GNU_style.py
+++ b/contrib/check_GNU_style.py
@@ -19,198 +19,9 @@
 # You should have received a copy of the GNU General Public License
 # along with GCC; see the file COPYING3.  If not see
 # <http://www.gnu.org/licenses/>.  */
-#
-# The script requires python packages, which can be installed via pip3
-# like this:
-# $ pip3 install unidiff termcolor 
 
-import sys
-import re
 import argparse
-import unittest
-
-try:
-    from termcolor import colored
-except ImportError:
-    print('termcolor module is missing (run: pip3 install termcolor)')
-    exit(3)
-
-try:
-    from unidiff import PatchSet
-except ImportError:
-    print('unidiff module is missing (run: pip3 install unidiff)')
-    exit(3)
-
-from itertools import *
-
-ws_char = 'â??'
-ts = 8
-
-def error_string(s):
-    return colored(s, 'red', attrs = ['bold'])
-
-class CheckError:
-    def __init__(self, filename, lineno, console_error, error_message,
-        column = -1):
-        self.filename = filename
-        self.lineno = lineno
-        self.console_error = console_error
-        self.error_message = error_message
-        self.column = column
-
-    def error_location(self):
-        return '%s:%d:%d:' % (self.filename, self.lineno,
-            self.column if self.column != -1 else -1)
-
-class LineLengthCheck:
-    def __init__(self):
-        self.limit = 80
-        self.expanded_tab = ' ' * ts
-
-    def check(self, filename, lineno, line):
-        line_expanded = line.replace('\t', self.expanded_tab)
-        if len(line_expanded) > self.limit:
-            return CheckError(filename, lineno,
-                line_expanded[:self.limit]
-                    + error_string(line_expanded[self.limit:]),
-                'lines should not exceed 80 characters', self.limit)
-
-        return None
-
-class SpacesCheck:
-    def __init__(self):
-        self.expanded_tab = ' ' * ts
-
-    def check(self, filename, lineno, line):
-        i = line.find(self.expanded_tab)
-        if i != -1:
-            return CheckError(filename, lineno,
-                line.replace(self.expanded_tab, error_string(ws_char * ts)),
-                'blocks of 8 spaces should be replaced with tabs', i)
-
-class TrailingWhitespaceCheck:
-    def __init__(self):
-        self.re = re.compile('(\s+)$')
-
-    def check(self, filename, lineno, line):
-        m = self.re.search(line)
-        if m != None:
-            return CheckError(filename, lineno,
-                line[:m.start(1)] + error_string(ws_char * len(m.group(1)))
-                + line[m.end(1):],
-                'trailing whitespace', m.start(1))
-
-class SentenceSeparatorCheck:
-    def __init__(self):
-        self.re = re.compile('\w\.(\s|\s{3,})\w')
-
-    def check(self, filename, lineno, line):
-        m = self.re.search(line)
-        if m != None:
-            return CheckError(filename, lineno,
-                line[:m.start(1)] + error_string(ws_char * len(m.group(1)))
-                + line[m.end(1):],
-                'dot, space, space, new sentence', m.start(1))
-
-class SentenceEndOfCommentCheck:
-    def __init__(self):
-        self.re = re.compile('\w\.(\s{0,1}|\s{3,})\*/')
-
-    def check(self, filename, lineno, line):
-        m = self.re.search(line)
-        if m != None:
-            return CheckError(filename, lineno,
-                line[:m.start(1)] + error_string(ws_char * len(m.group(1)))
-                + line[m.end(1):],
-                'dot, space, space, end of comment', m.start(1))
-
-class SentenceDotEndCheck:
-    def __init__(self):
-        self.re = re.compile('\w(\s*\*/)')
-
-    def check(self, filename, lineno, line):
-        m = self.re.search(line)
-        if m != None:
-            return CheckError(filename, lineno,
-                line[:m.start(1)] + error_string(m.group(1)) + line[m.end(1):],
-                'dot, space, space, end of comment', m.start(1))
-
-class FunctionParenthesisCheck:
-    # TODO: filter out GTY stuff
-    def __init__(self):
-        self.re = re.compile('\w(\s{2,})?(\()')
-
-    def check(self, filename, lineno, line):
-        if '#define' in line:
-            return None
-
-        m = self.re.search(line)
-        if m != None:
-            return CheckError(filename, lineno,
-                line[:m.start(2)] + error_string(m.group(2)) + line[m.end(2):],
-                'there should be exactly one space between function name ' \
-                'and parenthesis', m.start(2))
-
-class SquareBracketCheck:
-    def __init__(self):
-        self.re = re.compile('\w\s+(\[)')
-
-    def check(self, filename, lineno, line):
-        m = self.re.search(line)
-        if m != None:
-            return CheckError(filename, lineno,
-                line[:m.start(1)] + error_string(m.group(1)) + line[m.end(1):],
-                'there should be no space before a left square bracket',
-                m.start(1))
-
-class ClosingParenthesisCheck:
-    def __init__(self):
-        self.re = re.compile('\S\s+(\))')
-
-    def check(self, filename, lineno, line):
-        m = self.re.search(line)
-        if m != None:
-            return CheckError(filename, lineno,
-                line[:m.start(1)] + error_string(m.group(1)) + line[m.end(1):],
-                'there should be no space before closing parenthesis',
-                m.start(1))
-
-class BracesOnSeparateLineCheck:
-    # This will give false positives for C99 compound literals.
-
-    def __init__(self):
-        self.re = re.compile('(\)|else)\s*({)')
-
-    def check(self, filename, lineno, line):
-        m = self.re.search(line)
-        if m != None:
-            return CheckError(filename, lineno,
-                line[:m.start(2)] + error_string(m.group(2)) + line[m.end(2):],
-                'braces should be on a separate line', m.start(2))
-
-class TrailinigOperatorCheck:
-    def __init__(self):
-        regex = '^\s.*(([^a-zA-Z_]\*)|([-%<=&|^?])|([^*]/)|([^:][+]))$'
-        self.re = re.compile(regex)
-
-    def check(self, filename, lineno, line):
-        m = self.re.search(line)
-        if m != None:
-            return CheckError(filename, lineno,
-                line[:m.start(1)] + error_string(m.group(1)) + line[m.end(1):],
-                'trailing operator', m.start(1))
-
-class LineLengthTest(unittest.TestCase):
-    def setUp(self):
-        self.check = LineLengthCheck()
-
-    def test_line_length_check_basic(self):
-        r = self.check.check('foo', 123, self.check.limit * 'a' + ' = 123;')
-        self.assertIsNotNone(r)
-        self.assertEqual('foo', r.filename)
-        self.assertEqual(80, r.column)
-        self.assertEqual(r.console_error,
-            self.check.limit * 'a' + error_string(' = 123;'))
+from check_GNU_style_lib import check_GNU_style_file
 
 def main():
     parser = argparse.ArgumentParser(description='Check GNU coding style.')
@@ -219,60 +30,6 @@ def main():
         help = 'Display format',
         choices = ['stdio', 'quickfix'])
     args = parser.parse_args()
+    check_GNU_style_file(args.file, args.format)
 
-    checks = [LineLengthCheck(), SpacesCheck(), TrailingWhitespaceCheck(),
-        SentenceSeparatorCheck(), SentenceEndOfCommentCheck(),
-        SentenceDotEndCheck(), FunctionParenthesisCheck(),
-        SquareBracketCheck(), ClosingParenthesisCheck(),
-        BracesOnSeparateLineCheck(), TrailinigOperatorCheck()]
-    errors = []
-
-    with open(args.file, 'rb') as diff_file:
-        patch = PatchSet(diff_file, encoding = 'utf-8')
-
-    for pfile in patch.added_files + patch.modified_files:
-        t = pfile.target_file.lstrip('b/')
-        # Skip testsuite files
-        if 'testsuite' in t:
-            continue
-
-        for hunk in pfile:
-            delta = 0
-            for line in hunk:
-                if line.is_added and line.target_line_no != None:
-                    for check in checks:
-                        e = check.check(t, line.target_line_no, line.value)
-                        if e != None:
-                            errors.append(e)
-
-    if args.format == 'stdio':
-        fn = lambda x: x.error_message
-        i = 1
-        for (k, errors) in groupby(sorted(errors, key = fn), fn):
-            errors = list(errors)
-            print('=== ERROR type #%d: %s (%d error(s)) ==='
-                % (i, k, len(errors)))
-            i += 1
-            for e in errors:
-                print(e.error_location () + e.console_error)
-            print()
-
-        exit(0 if len(errors) == 0 else 1)
-    elif args.format == 'quickfix':
-        f = 'errors.err'
-        with open(f, 'w+') as qf:
-            for e in errors:
-                qf.write('%s%s\n' % (e.error_location(), e.error_message))
-        if len(errors) == 0:
-            exit(0)
-        else:
-            print('%d error(s) written to %s file.' % (len(errors), f))
-            exit(1)
-    else:
-        assert False
-
-if __name__ == '__main__':
-    if len(sys.argv) > 1:
-        main()
-    else:
-        unittest.main()
+main()
diff --git a/contrib/check_GNU_style_lib.py b/contrib/check_GNU_style_lib.py
new file mode 100755
index 0000000..a1224c1
--- /dev/null
+++ b/contrib/check_GNU_style_lib.py
@@ -0,0 +1,267 @@
+#!/usr/bin/env python3
+#
+# Checks some of the GNU style formatting rules in a set of patches.
+# The script is a rewritten of the same bash script and should eventually
+# replace the former script.
+#
+# This file is part of GCC.
+#
+# GCC is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free
+# Software Foundation; either version 3, or (at your option) any later
+# version.
+#
+# GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GCC; see the file COPYING3.  If not see
+# <http://www.gnu.org/licenses/>.  */
+#
+# The script requires python packages, which can be installed via pip3
+# like this:
+# $ pip3 install unidiff termcolor
+
+import sys
+import re
+import unittest
+
+try:
+    from termcolor import colored
+except ImportError:
+    print('termcolor module is missing (run: pip3 install termcolor)')
+    exit(3)
+
+try:
+    from unidiff import PatchSet
+except ImportError:
+    print('unidiff module is missing (run: pip3 install unidiff)')
+    exit(3)
+
+from itertools import *
+
+ws_char = 'â??'
+ts = 8
+
+def error_string(s):
+    return colored(s, 'red', attrs = ['bold'])
+
+class CheckError:
+    def __init__(self, filename, lineno, console_error, error_message,
+        column = -1):
+        self.filename = filename
+        self.lineno = lineno
+        self.console_error = console_error
+        self.error_message = error_message
+        self.column = column
+
+    def error_location(self):
+        return '%s:%d:%d:' % (self.filename, self.lineno,
+            self.column if self.column != -1 else -1)
+
+class LineLengthCheck:
+    def __init__(self):
+        self.limit = 80
+        self.expanded_tab = ' ' * ts
+
+    def check(self, filename, lineno, line):
+        line_expanded = line.replace('\t', self.expanded_tab)
+        if len(line_expanded) > self.limit:
+            return CheckError(filename, lineno,
+                line_expanded[:self.limit]
+                    + error_string(line_expanded[self.limit:]),
+                'lines should not exceed 80 characters', self.limit)
+
+        return None
+
+class SpacesCheck:
+    def __init__(self):
+        self.expanded_tab = ' ' * ts
+
+    def check(self, filename, lineno, line):
+        i = line.find(self.expanded_tab)
+        if i != -1:
+            return CheckError(filename, lineno,
+                line.replace(self.expanded_tab, error_string(ws_char * ts)),
+                'blocks of 8 spaces should be replaced with tabs', i)
+
+class TrailingWhitespaceCheck:
+    def __init__(self):
+        self.re = re.compile('(\s+)$')
+
+    def check(self, filename, lineno, line):
+        m = self.re.search(line)
+        if m != None:
+            return CheckError(filename, lineno,
+                line[:m.start(1)] + error_string(ws_char * len(m.group(1)))
+                + line[m.end(1):],
+                'trailing whitespace', m.start(1))
+
+class SentenceSeparatorCheck:
+    def __init__(self):
+        self.re = re.compile('\w\.(\s|\s{3,})\w')
+
+    def check(self, filename, lineno, line):
+        m = self.re.search(line)
+        if m != None:
+            return CheckError(filename, lineno,
+                line[:m.start(1)] + error_string(ws_char * len(m.group(1)))
+                + line[m.end(1):],
+                'dot, space, space, new sentence', m.start(1))
+
+class SentenceEndOfCommentCheck:
+    def __init__(self):
+        self.re = re.compile('\w\.(\s{0,1}|\s{3,})\*/')
+
+    def check(self, filename, lineno, line):
+        m = self.re.search(line)
+        if m != None:
+            return CheckError(filename, lineno,
+                line[:m.start(1)] + error_string(ws_char * len(m.group(1)))
+                + line[m.end(1):],
+                'dot, space, space, end of comment', m.start(1))
+
+class SentenceDotEndCheck:
+    def __init__(self):
+        self.re = re.compile('\w(\s*\*/)')
+
+    def check(self, filename, lineno, line):
+        m = self.re.search(line)
+        if m != None:
+            return CheckError(filename, lineno,
+                line[:m.start(1)] + error_string(m.group(1)) + line[m.end(1):],
+                'dot, space, space, end of comment', m.start(1))
+
+class FunctionParenthesisCheck:
+    # TODO: filter out GTY stuff
+    def __init__(self):
+        self.re = re.compile('\w(\s{2,})?(\()')
+
+    def check(self, filename, lineno, line):
+        if '#define' in line:
+            return None
+
+        m = self.re.search(line)
+        if m != None:
+            return CheckError(filename, lineno,
+                line[:m.start(2)] + error_string(m.group(2)) + line[m.end(2):],
+                'there should be exactly one space between function name ' \
+                'and parenthesis', m.start(2))
+
+class SquareBracketCheck:
+    def __init__(self):
+        self.re = re.compile('\w\s+(\[)')
+
+    def check(self, filename, lineno, line):
+        m = self.re.search(line)
+        if m != None:
+            return CheckError(filename, lineno,
+                line[:m.start(1)] + error_string(m.group(1)) + line[m.end(1):],
+                'there should be no space before a left square bracket',
+                m.start(1))
+
+class ClosingParenthesisCheck:
+    def __init__(self):
+        self.re = re.compile('\S\s+(\))')
+
+    def check(self, filename, lineno, line):
+        m = self.re.search(line)
+        if m != None:
+            return CheckError(filename, lineno,
+                line[:m.start(1)] + error_string(m.group(1)) + line[m.end(1):],
+                'there should be no space before closing parenthesis',
+                m.start(1))
+
+class BracesOnSeparateLineCheck:
+    # This will give false positives for C99 compound literals.
+
+    def __init__(self):
+        self.re = re.compile('(\)|else)\s*({)')
+
+    def check(self, filename, lineno, line):
+        m = self.re.search(line)
+        if m != None:
+            return CheckError(filename, lineno,
+                line[:m.start(2)] + error_string(m.group(2)) + line[m.end(2):],
+                'braces should be on a separate line', m.start(2))
+
+class TrailinigOperatorCheck:
+    def __init__(self):
+        regex = '^\s.*(([^a-zA-Z_]\*)|([-%<=&|^?])|([^*]/)|([^:][+]))$'
+        self.re = re.compile(regex)
+
+    def check(self, filename, lineno, line):
+        m = self.re.search(line)
+        if m != None:
+            return CheckError(filename, lineno,
+                line[:m.start(1)] + error_string(m.group(1)) + line[m.end(1):],
+                'trailing operator', m.start(1))
+
+class LineLengthTest(unittest.TestCase):
+    def setUp(self):
+        self.check = LineLengthCheck()
+
+    def test_line_length_check_basic(self):
+        r = self.check.check('foo', 123, self.check.limit * 'a' + ' = 123;')
+        self.assertIsNotNone(r)
+        self.assertEqual('foo', r.filename)
+        self.assertEqual(80, r.column)
+        self.assertEqual(r.console_error,
+            self.check.limit * 'a' + error_string(' = 123;'))
+
+def check_GNU_style_file(file, format):
+    checks = [LineLengthCheck(), SpacesCheck(), TrailingWhitespaceCheck(),
+        SentenceSeparatorCheck(), SentenceEndOfCommentCheck(),
+        SentenceDotEndCheck(), FunctionParenthesisCheck(),
+        SquareBracketCheck(), ClosingParenthesisCheck(),
+        BracesOnSeparateLineCheck(), TrailinigOperatorCheck()]
+    errors = []
+
+    with open(file, 'rb') as diff_file:
+        patch = PatchSet(diff_file, encoding = 'utf-8')
+
+    for pfile in patch.added_files + patch.modified_files:
+        t = pfile.target_file.lstrip('b/')
+        # Skip testsuite files
+        if 'testsuite' in t:
+            continue
+
+        for hunk in pfile:
+            delta = 0
+            for line in hunk:
+                if line.is_added and line.target_line_no != None:
+                    for check in checks:
+                        e = check.check(t, line.target_line_no, line.value)
+                        if e != None:
+                            errors.append(e)
+
+    if format == 'stdio':
+        fn = lambda x: x.error_message
+        i = 1
+        for (k, errors) in groupby(sorted(errors, key = fn), fn):
+            errors = list(errors)
+            print('=== ERROR type #%d: %s (%d error(s)) ==='
+                % (i, k, len(errors)))
+            i += 1
+            for e in errors:
+                print(e.error_location () + e.console_error)
+            print()
+
+        exit(0 if len(errors) == 0 else 1)
+    elif format == 'quickfix':
+        f = 'errors.err'
+        with open(f, 'w+') as qf:
+            for e in errors:
+                qf.write('%s%s\n' % (e.error_location(), e.error_message))
+        if len(errors) == 0:
+            exit(0)
+        else:
+            print('%d error(s) written to %s file.' % (len(errors), f))
+            exit(1)
+    else:
+        assert False
+
+if __name__ == '__main__':
+    unittest.main()

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]