[tor-commits] [tor/master] add_c_file: Rename variables based on the type of path
teor at torproject.org
teor at torproject.org
Mon Jan 20 05:53:03 UTC 2020
commit eb336e23a6a0979cf0c8e68f3dcd6a825a4b210d
Author: teor <teor at torproject.org>
Date: Thu Jan 16 09:15:22 2020 +1000
add_c_file: Rename variables based on the type of path
* fname for generic file paths
* tor_fname for paths relative to the top-level tor directory
* src_fname for paths relative to tor's src directory
With prefixes as required to disambiguate different paths of the same
type.
Part of 32962.
---
scripts/maint/add_c_file.py | 101 ++++++++++++++++++++++----------------------
1 file changed, 51 insertions(+), 50 deletions(-)
diff --git a/scripts/maint/add_c_file.py b/scripts/maint/add_c_file.py
index 88a24a1cf..25a1be533 100755
--- a/scripts/maint/add_c_file.py
+++ b/scripts/maint/add_c_file.py
@@ -29,17 +29,17 @@ import os
import re
import time
-def tordir_file(name):
- """Make name relative to the current directory, which should be the
+def tordir_file(fname):
+ """Make fname relative to the current directory, which should be the
top-level tor directory. Also performs basic path simplifications."""
- return os.path.normpath(os.path.relpath(name))
+ return os.path.normpath(os.path.relpath(fname))
-def srcdir_file(name):
- """Make name relative to tor's "src" directory.
+def srcdir_file(tor_fname):
+ """Make tor_fname relative to tor's "src" directory.
Also performs basic path simplifications.
(This function takes paths relative to the top-level tor directory,
but outputs a path that is relative to tor's src directory.)"""
- return os.path.normpath(os.path.relpath(name, 'src'))
+ return os.path.normpath(os.path.relpath(tor_fname, 'src'))
def guard_macro(src_fname):
"""Return the guard macro that should be used for the header file
@@ -48,13 +48,13 @@ def guard_macro(src_fname):
td = src_fname.replace(".", "_").replace("/", "_").upper()
return "TOR_{}".format(td)
-def makeext(name, new_extension):
- """Replace the extension for the file called 'name' with 'new_extension'.
+def makeext(fname, new_extension):
+ """Replace the extension for the file called 'fname' with 'new_extension'.
This function takes and returns paths relative to either the top-level
tor directory, or tor's src directory, and returns the same kind
of path.
"""
- base = os.path.splitext(name)[0]
+ base = os.path.splitext(fname)[0]
return base + "." + new_extension
def instantiate_template(template, tor_fname):
@@ -154,11 +154,11 @@ class AutomakeChunk:
return False
- def insertMember(self, member):
+ def insertMember(self, new_tor_fname):
"""
- Add a new member to this chunk. Try to insert it in alphabetical
- order with matching indentation, but don't freak out too much if the
- source isn't consistent.
+ Add a new file name new_tor_fname to this chunk. Try to insert it in
+ alphabetical order with matching indentation, but don't freak out too
+ much if the source isn't consistent.
Assumes that this chunk is of the form:
FOOBAR = \
@@ -175,20 +175,21 @@ class AutomakeChunk:
m = re.match(r'(\s+)(\S+)(\s+)\\', line)
if not m:
continue
- prespace, fname, postspace = m.groups()
- if fname > member:
- self.insert_before(lineno, member, prespace, postspace)
+ prespace, cur_tor_fname, postspace = m.groups()
+ if cur_tor_fname > new_tor_fname:
+ self.insert_before(lineno, new_tor_fname, prespace, postspace)
return
- self.insert_at_end(member, prespace, postspace)
+ self.insert_at_end(new_tor_fname, prespace, postspace)
- def insert_before(self, lineno, member, prespace, postspace):
+ def insert_before(self, lineno, new_tor_fname, prespace, postspace):
self.lines.insert(lineno,
- "{}{}{}\\\n".format(prespace, member, postspace))
+ "{}{}{}\\\n".format(prespace, new_tor_fname,
+ postspace))
- def insert_at_end(self, member, prespace, postspace):
+ def insert_at_end(self, new_tor_fname, prespace, postspace):
lastline = self.lines[-1].strip()
self.lines[-1] = '{}{}{}\\\n'.format(prespace, lastline, postspace)
- self.lines.append("{}{}\n".format(prespace, member))
+ self.lines.append("{}{}\n".format(prespace, new_tor_fname))
def dump(self, f):
"""Write all the lines in this chunk to the file 'f'."""
@@ -215,15 +216,15 @@ class ParsedAutomake:
self.chunks.append(chunk)
self.by_type[chunk.kind.lower()] = chunk
- def add_file(self, fname, kind):
- """Insert a file of kind 'kind' to the appropriate section of this
- file. Return True if we added it.
+ def add_file(self, tor_fname, kind):
+ """Insert a file tor_fname of kind 'kind' to the appropriate
+ section of this file. Return True if we added it.
This function operates on paths relative to the top-level tor
directory.
"""
if kind.lower() in self.by_type:
- self.by_type[kind.lower()].insertMember(fname)
+ self.by_type[kind.lower()].insertMember(tor_fname)
return True
else:
return False
@@ -233,9 +234,9 @@ class ParsedAutomake:
for chunk in self.chunks:
chunk.dump(f)
-def get_include_am_location(fname):
- """Find the right include.am file for introducing a new file. Return None
- if we can't guess one.
+def get_include_am_location(tor_fname):
+ """Find the right include.am file for introducing a new file
+ tor_fname. Return None if we can't guess one.
Note that this function is imperfect because our include.am layout is
not (yet) consistent.
@@ -243,20 +244,20 @@ def get_include_am_location(fname):
This function operates on paths relative to the top-level tor directory.
"""
# Strip src for pattern matching, but add it back when returning the path
- td = srcdir_file(fname)
- m = re.match(r'^(lib|core|feature|app)/([a-z0-9_]*)/', td)
+ src_fname = srcdir_file(tor_fname)
+ m = re.match(r'^(lib|core|feature|app)/([a-z0-9_]*)/', src_fname)
if m:
return "src/{}/{}/include.am".format(m.group(1),m.group(2))
- if re.match(r'^test/', td):
+ if re.match(r'^test/', src_fname):
return "src/test/include.am"
return None
-def run(fn):
+def run(fname):
"""
- Create a new C file and H file corresponding to the filename "fn", and
- add them to the corresponding include.am.
+ Create a new C file and H file corresponding to the filename "fname",
+ and add them to the corresponding include.am.
This function operates on paths relative to the top-level tor directory.
"""
@@ -266,31 +267,31 @@ def run(fn):
assert(os.path.isdir("src"))
# Make the file name relative to the top-level tor directory
- fn = tordir_file(fn)
+ tor_fname = tordir_file(fname)
# And check that we're adding files to the "src" directory,
# with canonical paths
- assert(fn[:4] == "src/")
+ assert(tor_fname[:4] == "src/")
- cf = makeext(fn, "c")
- hf = makeext(fn, "h")
+ c_tor_fname = makeext(tor_fname, "c")
+ h_tor_fname = makeext(tor_fname, "h")
- if os.path.exists(cf):
- print("{} already exists".format(cf))
+ if os.path.exists(c_tor_fname):
+ print("{} already exists".format(c_tor_fname))
return 1
- if os.path.exists(hf):
- print("{} already exists".format(hf))
+ if os.path.exists(h_tor_fname):
+ print("{} already exists".format(h_tor_fname))
return 1
- with open(cf, 'w') as f:
- f.write(instantiate_template(C_FILE_TEMPLATE, cf))
+ with open(c_tor_fname, 'w') as f:
+ f.write(instantiate_template(C_FILE_TEMPLATE, c_tor_fname))
- with open(hf, 'w') as f:
- f.write(instantiate_template(HEADER_TEMPLATE, hf))
+ with open(h_tor_fname, 'w') as f:
+ f.write(instantiate_template(HEADER_TEMPLATE, h_tor_fname))
- iam = get_include_am_location(cf)
+ iam = get_include_am_location(c_tor_fname)
if iam is None or not os.path.exists(iam):
print("Made files successfully but couldn't identify include.am for {}"
- .format(cf))
+ .format(c_tor_fname))
return 1
amfile = ParsedAutomake()
@@ -302,8 +303,8 @@ def run(fn):
cur_chunk = AutomakeChunk()
amfile.addChunk(cur_chunk)
- amfile.add_file(cf, "sources")
- amfile.add_file(hf, "headers")
+ amfile.add_file(c_tor_fname, "sources")
+ amfile.add_file(h_tor_fname, "headers")
with open(iam+".tmp", 'w') as f:
amfile.dump(f)
More information about the tor-commits
mailing list