tor/scripts/maint/codetool.py
Samanta Navarro 4a0cd79588 Fix typos.
Typos found with codespell.

Please keep in mind that this should have impact on actual code
and must be carefully evaluated:

src/core/or/lttng_circuit.inc
-    ctf_enum_value("CONTROLER", CIRCUIT_PURPOSE_CONTROLLER)
+    ctf_enum_value("CONTROLLER", CIRCUIT_PURPOSE_CONTROLLER)
2020-11-12 11:44:09 -05:00

183 lines
5.1 KiB
Python
Executable File

#!/usr/bin/env python3
# Copyright (c) 2020, The Tor Project, Inc.
# See LICENSE for licensing information.
#
# DO NOT COMMIT OR MERGE CODE THAT IS RUN THROUGH THIS TOOL YET.
#
# WE ARE STILL DISCUSSING OUR DESIRED STYLE AND ITERATING ON IT,
# ALONG WITH THE TOOLS THAT ACHIEVE IT.
# (12 Feb 2020)
#
"""
This program uses a set of pluggable filters to inspect and transform
our C code.
"""
import os
import re
import sys
class Filter:
"""A Filter transforms a string containing a C program."""
def __init__(self):
pass
def transform(self, s):
return s
class CompoundFilt(Filter):
"""A CompoundFilt runs another set of filters, in sequence."""
def __init__(self, items=()):
super().__init__()
self._filters = list(items)
def add(self, filt):
self._filters.append(filt)
return self
def transform(self, s):
for f in self._filters:
s = f.transform(s)
return s
class SplitError(Exception):
"""Exception: raised if split_comments() can't understand a C file."""
pass
def split_comments(s):
r"""Iterate over the C code in 's', and yield a sequence of (code,
comment) pairs. Each pair will contain either a nonempty piece
of code, a nonempty comment, or both.
>>> list(split_comments("hello // world\n"))
[('hello ', '// world'), ('\n', '')]
>>> list(split_comments("a /* b cd */ efg // hi"))
[('a ', '/* b cd */'), (' efg ', '// hi')]
"""
# Matches a block of code without any comments.
PAT_CODE = re.compile(r'''^(?: [^/"']+ |
"(?:[^\\"]+|\\.)*" |
'(?:[^\\']+|\\.)*' |
/[^/*]
)*''', re.VERBOSE|re.DOTALL)
# Matches a C99 "//" comment.
PAT_C99_COMMENT = re.compile(r'^//.*$', re.MULTILINE)
# Matches a C "/* */" comment.
PAT_C_COMMENT = re.compile(r'^/\*(?:[^*]|\*+[^*/])*\*+/', re.DOTALL)
while True:
# Find some non-comment code at the start of the string.
m = PAT_CODE.match(s)
# If we found some code here, save it and advance the string.
# Otherwise set 'code' to "".
if m:
code = m.group(0)
s = s[m.end():]
else:
code = ""
# Now we have a comment, or the end of the string. Find out which
# one, and how long it is.
if s.startswith("//"):
m = PAT_C99_COMMENT.match(s)
else:
m = PAT_C_COMMENT.match(s)
# If we got a comment, save it and advance the string. Otherwise
# set 'comment' to "".
if m:
comment = m.group(0)
s = s[m.end():]
else:
comment = ""
# If we found no code and no comment, we should be at the end of
# the string...
if code == "" and comment == "":
if s:
# But in case we *aren't* at the end of the string, raise
# an error.
raise SplitError()
# ... all is well, we're done scanning the code.
return
yield (code, comment)
class IgnoreCommentsFilt(Filter):
"""Wrapper: applies another filter to C code only, excluding comments.
"""
def __init__(self, filt):
super().__init__()
self._filt = filt
def transform(self, s):
result = []
for code, comment in split_comments(s):
result.append(self._filt.transform(code))
result.append(comment)
return "".join(result)
class RegexFilt(Filter):
"""A regex filter applies a regular expression to some C code."""
def __init__(self, pat, replacement, flags=0):
super().__init__()
self._pat = re.compile(pat, flags)
self._replacement = replacement
def transform(self, s):
s, _ = self._pat.subn(self._replacement, s)
return s
def revise(fname, filt):
"""Run 'filt' on the contents of the file in 'fname'. If any
changes are made, then replace the file with its new contents.
Otherwise, leave the file alone.
"""
contents = open(fname, 'r').read()
result = filt.transform(contents)
if result == contents:
return
tmpname = "{}_codetool_tmp".format(fname)
try:
with open(tmpname, 'w') as f:
f.write(result)
os.rename(tmpname, fname)
except:
os.unlink(tmpname)
raise
##############################
# Filtering rules.
##############################
# Make sure that there is a newline after the first comma in a MOCK_IMPL()
BREAK_MOCK_IMPL = RegexFilt(
r'^MOCK_IMPL\(([^,]+),\s*(\S+)',
r'MOCK_IMPL(\1,\n\2',
re.MULTILINE)
# Make sure there is no newline between } and a loop iteration terminator.
RESTORE_SMARTLIST_END = RegexFilt(
r'}\s*(SMARTLIST|DIGESTMAP|DIGEST256MAP|STRMAP|MAP)_FOREACH_END\s*\(',
r'} \1_FOREACH_END (',
re.MULTILINE)
F = CompoundFilt()
F.add(IgnoreCommentsFilt(CompoundFilt([
RESTORE_SMARTLIST_END,
BREAK_MOCK_IMPL])))
if __name__ == '__main__':
for fname in sys.argv[1:]:
revise(fname, F)