1 #!/usr/bin/env python3
2
3 # Copyright (C) 2017-2023 Free Software Foundation, Inc.
4 #
5 # Checks some of the GNU style formatting rules in a set of patches.
6 # The script is a rewritten of the same bash script and should eventually
7 # replace the former script.
8 #
9 # This file is part of GCC.
10 #
11 # GCC is free software; you can redistribute it and/or modify it under
12 # the terms of the GNU General Public License as published by the Free
13 # Software Foundation; either version 3, or (at your option) any later
14 # version.
15 #
16 # GCC is distributed in the hope that it will be useful, but WITHOUT ANY
17 # WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 # for more details.
20 #
21 # You should have received a copy of the GNU General Public License
22 # along with GCC; see the file COPYING3. If not see
23 # <http://www.gnu.org/licenses/>. */
24 #
25 # The script requires python packages, which can be installed via pip3
26 # like this:
27 # $ pip3 install unidiff termcolor
28
29 import sys
30 import re
31 import unittest
32
33 def import_pip3(*args):
34 missing=[]
35 for (module, names) in args:
36 try:
37 lib = __import__(module)
38 except ImportError:
39 missing.append(module)
40 continue
41 if not isinstance(names, list):
42 names=[names]
43 for name in names:
44 globals()[name]=getattr(lib, name)
45 if len(missing) > 0:
46 missing_and_sep = ' and '.join(missing)
47 missing_space_sep = ' '.join(missing)
48 print('%s %s missing (run: pip3 install %s)'
49 % (missing_and_sep,
50 ("module is" if len(missing) == 1 else "modules are"),
51 missing_space_sep))
52 exit(3)
53
54 import_pip3(('termcolor', 'colored'),
55 ('unidiff', 'PatchSet'))
56
57 from itertools import *
58
59 ws_char = '█'
60 ts = 8
61
62 def error_string(s):
63 return colored(s, 'red', attrs = ['bold'])
64
65 class ESC[4;38;5;81mCheckError:
66 def __init__(self, filename, lineno, console_error, error_message,
67 column = -1):
68 self.filename = filename
69 self.lineno = lineno
70 self.console_error = console_error
71 self.error_message = error_message
72 self.column = column
73
74 def error_location(self):
75 return '%s:%d:%d:' % (self.filename, self.lineno,
76 self.column if self.column != -1 else -1)
77
78 class ESC[4;38;5;81mLineLengthCheck:
79 def __init__(self):
80 self.limit = 80
81 self.expanded_tab = ' ' * ts
82
83 def check(self, filename, lineno, line):
84 line_expanded = line.replace('\t', self.expanded_tab)
85 if len(line_expanded) > self.limit:
86 return CheckError(filename, lineno,
87 line_expanded[:self.limit]
88 + error_string(line_expanded[self.limit:]),
89 'lines should not exceed 80 characters', self.limit)
90
91 return None
92
93 class ESC[4;38;5;81mSpacesCheck:
94 def __init__(self):
95 self.expanded_tab = ' ' * ts
96
97 def check(self, filename, lineno, line):
98 i = line.find(self.expanded_tab)
99 if i != -1:
100 return CheckError(filename, lineno,
101 line.replace(self.expanded_tab, error_string(ws_char * ts)),
102 'blocks of 8 spaces should be replaced with tabs', i)
103
104 class ESC[4;38;5;81mSpacesAndTabsMixedCheck:
105 def __init__(self):
106 self.re = re.compile('\ \t')
107
108 def check(self, filename, lineno, line):
109 stripped = line.lstrip()
110 start = line[:len(line) - len(stripped)]
111 if self.re.search(line):
112 return CheckError(filename, lineno,
113 error_string(start.replace('\t', ws_char * ts)) + line[len(start):],
114 'a space should not precede a tab', 0)
115
116 class ESC[4;38;5;81mTrailingWhitespaceCheck:
117 def __init__(self):
118 self.re = re.compile('(\s+)$')
119
120 def check(self, filename, lineno, line):
121 assert(len(line) == 0 or line[-1] != '\n')
122 m = self.re.search(line)
123 if m != None:
124 return CheckError(filename, lineno,
125 line[:m.start(1)] + error_string(ws_char * len(m.group(1)))
126 + line[m.end(1):],
127 'trailing whitespace', m.start(1))
128
129 class ESC[4;38;5;81mSentenceSeparatorCheck:
130 def __init__(self):
131 self.re = re.compile('\w\.(\s|\s{3,})\w')
132
133 def check(self, filename, lineno, line):
134 m = self.re.search(line)
135 if m != None:
136 return CheckError(filename, lineno,
137 line[:m.start(1)] + error_string(ws_char * len(m.group(1)))
138 + line[m.end(1):],
139 'dot, space, space, new sentence', m.start(1))
140
141 class ESC[4;38;5;81mSentenceEndOfCommentCheck:
142 def __init__(self):
143 self.re = re.compile('\w\.(\s{0,1}|\s{3,})\*/')
144
145 def check(self, filename, lineno, line):
146 m = self.re.search(line)
147 if m != None:
148 return CheckError(filename, lineno,
149 line[:m.start(1)] + error_string(ws_char * len(m.group(1)))
150 + line[m.end(1):],
151 'dot, space, space, end of comment', m.start(1))
152
153 class ESC[4;38;5;81mSentenceDotEndCheck:
154 def __init__(self):
155 self.re = re.compile('\w(\s*\*/)')
156
157 def check(self, filename, lineno, line):
158 m = self.re.search(line)
159 if m != None:
160 return CheckError(filename, lineno,
161 line[:m.start(1)] + error_string(m.group(1)) + line[m.end(1):],
162 'dot, space, space, end of comment', m.start(1))
163
164 class ESC[4;38;5;81mFunctionParenthesisCheck:
165 # TODO: filter out GTY stuff
166 def __init__(self):
167 self.re = re.compile('\w(\s{2,})?(\()')
168
169 def check(self, filename, lineno, line):
170 if '#define' in line:
171 return None
172
173 m = self.re.search(line)
174 if m != None:
175 return CheckError(filename, lineno,
176 line[:m.start(2)] + error_string(m.group(2)) + line[m.end(2):],
177 'there should be exactly one space between function name ' \
178 'and parenthesis', m.start(2))
179
180 class ESC[4;38;5;81mSquareBracketCheck:
181 def __init__(self):
182 self.re = re.compile('\w\s+(\[)')
183
184 def check(self, filename, lineno, line):
185 m = self.re.search(line)
186 if m != None:
187 return CheckError(filename, lineno,
188 line[:m.start(1)] + error_string(m.group(1)) + line[m.end(1):],
189 'there should be no space before a left square bracket',
190 m.start(1))
191
192 class ESC[4;38;5;81mClosingParenthesisCheck:
193 def __init__(self):
194 self.re = re.compile('\S\s+(\))')
195
196 def check(self, filename, lineno, line):
197 m = self.re.search(line)
198 if m != None:
199 return CheckError(filename, lineno,
200 line[:m.start(1)] + error_string(m.group(1)) + line[m.end(1):],
201 'there should be no space before closing parenthesis',
202 m.start(1))
203
204 class ESC[4;38;5;81mBracesOnSeparateLineCheck:
205 # This will give false positives for C99 compound literals.
206
207 def __init__(self):
208 self.re = re.compile('(\)|else)\s*({)')
209
210 def check(self, filename, lineno, line):
211 m = self.re.search(line)
212 if m != None:
213 return CheckError(filename, lineno,
214 line[:m.start(2)] + error_string(m.group(2)) + line[m.end(2):],
215 'braces should be on a separate line', m.start(2))
216
217 class ESC[4;38;5;81mTrailinigOperatorCheck:
218 def __init__(self):
219 regex = '^\s.*(([^a-zA-Z_]\*)|([-%<=&|^?])|([^*]/)|([^:][+]))$'
220 self.re = re.compile(regex)
221
222 def check(self, filename, lineno, line):
223 m = self.re.search(line)
224 if m != None:
225 return CheckError(filename, lineno,
226 line[:m.start(1)] + error_string(m.group(1)) + line[m.end(1):],
227 'trailing operator', m.start(1))
228
229 class ESC[4;38;5;81mLineLengthTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
230 def setUp(self):
231 self.check = LineLengthCheck()
232
233 def test_line_length_check_basic(self):
234 r = self.check.check('foo', 123, self.check.limit * 'a' + ' = 123;')
235 self.assertIsNotNone(r)
236 self.assertEqual('foo', r.filename)
237 self.assertEqual(80, r.column)
238 self.assertEqual(r.console_error,
239 self.check.limit * 'a' + error_string(' = 123;'))
240
241 class ESC[4;38;5;81mTrailingWhitespaceTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
242 def setUp(self):
243 self.check = TrailingWhitespaceCheck()
244
245 def test_trailing_whitespace_check_basic(self):
246 r = self.check.check('foo', 123, 'a = 123;')
247 self.assertIsNone(r)
248 r = self.check.check('foo', 123, 'a = 123; ')
249 self.assertIsNotNone(r)
250 r = self.check.check('foo', 123, 'a = 123;\t')
251 self.assertIsNotNone(r)
252
253 class ESC[4;38;5;81mSpacesAndTabsMixedTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
254 def setUp(self):
255 self.check = SpacesAndTabsMixedCheck()
256
257 def test_trailing_whitespace_check_basic(self):
258 r = self.check.check('foo', 123, ' \ta = 123;')
259 self.assertEqual('foo', r.filename)
260 self.assertEqual(0, r.column)
261 self.assertIsNotNone(r.console_error)
262 r = self.check.check('foo', 123, ' \t a = 123;')
263 self.assertIsNotNone(r.console_error)
264 r = self.check.check('foo', 123, '\t a = 123;')
265 self.assertIsNone(r)
266
267 def check_GNU_style_file(file, format):
268 checks = [LineLengthCheck(), SpacesCheck(), TrailingWhitespaceCheck(),
269 SentenceSeparatorCheck(), SentenceEndOfCommentCheck(),
270 SentenceDotEndCheck(), FunctionParenthesisCheck(),
271 SquareBracketCheck(), ClosingParenthesisCheck(),
272 BracesOnSeparateLineCheck(), TrailinigOperatorCheck(),
273 SpacesAndTabsMixedCheck()]
274 errors = []
275
276 patch = PatchSet(file)
277
278 for pfile in patch.added_files + patch.modified_files:
279 t = pfile.target_file.lstrip('b/')
280 # Skip testsuite files
281 if 'testsuite' in t or t.endswith('.py'):
282 continue
283
284 for hunk in pfile:
285 delta = 0
286 for line in hunk:
287 if line.is_added and line.target_line_no != None:
288 for check in checks:
289 line_chomp = line.value.replace('\n', '')
290 e = check.check(t, line.target_line_no, line_chomp)
291 if e != None:
292 errors.append(e)
293
294 if format == 'stdio':
295 fn = lambda x: x.error_message
296 i = 1
297 for (k, errors) in groupby(sorted(errors, key = fn), fn):
298 errors = list(errors)
299 print('=== ERROR type #%d: %s (%d error(s)) ==='
300 % (i, k, len(errors)))
301 i += 1
302 for e in errors:
303 print(e.error_location () + e.console_error)
304 print()
305
306 exit(0 if len(errors) == 0 else 1)
307 elif format == 'quickfix':
308 f = 'errors.err'
309 with open(f, 'w+') as qf:
310 for e in errors:
311 qf.write('%s%s\n' % (e.error_location(), e.error_message))
312 if len(errors) == 0:
313 exit(0)
314 else:
315 print('%d error(s) written to %s file.' % (len(errors), f))
316 exit(1)
317 else:
318 assert False
319
320 if __name__ == '__main__':
321 unittest.main()