439 lines
13 KiB
Python
Executable File
439 lines
13 KiB
Python
Executable File
#!/usr/bin/env python
|
|
|
|
import os
|
|
import subprocess
|
|
import tempfile
|
|
import sys
|
|
import filecmp
|
|
import optparse
|
|
import shutil
|
|
import difflib
|
|
import re
|
|
|
|
def hg_modified_files():
|
|
files = os.popen ('hg st -nma')
|
|
return [filename.strip() for filename in files]
|
|
|
|
def copy_file(filename):
|
|
[tmp,pathname] = tempfile.mkstemp()
|
|
src = open(filename, 'r')
|
|
dst = open(pathname, 'w')
|
|
for line in src:
|
|
dst.write(line)
|
|
dst.close()
|
|
src.close()
|
|
return pathname
|
|
|
|
# generate a temporary configuration file
|
|
def uncrustify_config_file(level):
|
|
level2 = """
|
|
nl_collapse_empty_body=False
|
|
nl_if_brace=Add
|
|
nl_brace_else=Add
|
|
nl_elseif_brace=Add
|
|
nl_else_brace=Add
|
|
nl_while_brace=Add
|
|
nl_do_brace=Add
|
|
nl_for_brace=Add
|
|
nl_brace_while=Add
|
|
nl_switch_brace=Add
|
|
nl_after_case=True
|
|
nl_namespace_brace=Remove
|
|
nl_after_brace_open=True
|
|
nl_class_leave_one_liners=False
|
|
nl_enum_leave_one_liners=False
|
|
nl_func_leave_one_liners=False
|
|
nl_if_leave_one_liners=False
|
|
nl_class_colon=Ignore
|
|
nl_after_access_spec=1
|
|
nl_after_semicolon=True
|
|
pos_class_colon=Lead
|
|
pos_class_comma=Trail
|
|
pos_bool=Lead
|
|
nl_class_init_args=Add
|
|
nl_template_class=Add
|
|
nl_class_brace=Add
|
|
# does not work very well
|
|
nl_func_type_name=Ignore
|
|
nl_func_scope_name=Ignore
|
|
nl_func_type_name_class=Ignore
|
|
nl_func_proto_type_name=Ignore
|
|
# function\\n(
|
|
nl_func_paren=Remove
|
|
nl_fdef_brace=Add
|
|
nl_struct_brace=Add
|
|
nl_enum_brace=Add
|
|
nl_union_brace=Add
|
|
mod_full_brace_do=Add
|
|
mod_full_brace_for=Add
|
|
mod_full_brace_if=Add
|
|
mod_full_brace_while=Add
|
|
mod_full_brace_for=Add
|
|
mod_remove_extra_semicolon=True
|
|
# max code width
|
|
#code_width=128
|
|
#ls_for_split_full=True
|
|
#ls_func_split_full=True
|
|
"""
|
|
level1 = """
|
|
# extra spaces here and there
|
|
sp_func_proto_paren=Add
|
|
sp_func_def_paren=Add
|
|
sp_func_call_paren=Add
|
|
sp_brace_typedef=Add
|
|
sp_enum_assign=Add
|
|
sp_before_sparen=Add
|
|
sp_after_semi_for=Add
|
|
sp_arith=Add
|
|
sp_assign=Add
|
|
sp_compare=Add
|
|
sp_func_class_paren=Add
|
|
sp_after_type=Add
|
|
sp_type_func=Add
|
|
sp_angle_paren=Add
|
|
"""
|
|
level0 = """
|
|
sp_after_semi_for=Ignore
|
|
sp_before_sparen=Ignore
|
|
sp_type_func=Ignore
|
|
sp_after_type=Ignore
|
|
nl_class_leave_one_liners=True
|
|
nl_enum_leave_one_liners=True
|
|
nl_func_leave_one_liners=True
|
|
nl_assign_leave_one_liners=True
|
|
#nl_collapse_empty_body=False
|
|
nl_getset_leave_one_liners=True
|
|
nl_if_leave_one_liners=True
|
|
nl_fdef_brace=Ignore
|
|
# finally, indentation configuration
|
|
indent_with_tabs=0
|
|
indent_namespace=false
|
|
indent_columns=2
|
|
indent_brace=2
|
|
indent_case_brace=2
|
|
indent_class=true
|
|
indent_class_colon=True
|
|
# alignment
|
|
indent_align_assign=False
|
|
align_left_shift=True
|
|
# comment reformating disabled
|
|
cmt_reflow_mode=1 # do not touch comments at all
|
|
cmt_indent_multi=False # really, do not touch them
|
|
"""
|
|
[tmp,pathname] = tempfile.mkstemp()
|
|
dst = open(pathname, 'w')
|
|
dst.write(level0)
|
|
if level >= 1:
|
|
dst.write(level1)
|
|
if level >= 2:
|
|
dst.write(level2)
|
|
dst.close()
|
|
return pathname
|
|
|
|
class PatchChunkLine:
|
|
SRC = 1
|
|
DST = 2
|
|
BOTH = 3
|
|
def __init__(self):
|
|
self.__type = 0
|
|
self.__line = ''
|
|
def set_src(self,line):
|
|
self.__type = self.SRC
|
|
self.__line = line
|
|
def set_dst(self,line):
|
|
self.__type = self.DST
|
|
self.__line = line
|
|
def set_both(self,line):
|
|
self.__type = self.BOTH
|
|
self.__line = line
|
|
def append_to_line(self, s):
|
|
self.__line = self.__line + s
|
|
def line(self):
|
|
return self.__line
|
|
def is_src(self):
|
|
return self.__type == self.SRC or self.__type == self.BOTH
|
|
def is_dst(self):
|
|
return self.__type == self.DST or self.__type == self.BOTH
|
|
def write(self, f):
|
|
if self.__type == self.SRC:
|
|
f.write('-%s\n' % self.__line)
|
|
elif self.__type == self.DST:
|
|
f.write('+%s\n' % self.__line)
|
|
elif self.__type == self.BOTH:
|
|
f.write(' %s\n' % self.__line)
|
|
else:
|
|
raise Exception('invalid patch')
|
|
|
|
|
|
class PatchChunk:
|
|
def __init__(self, src_pos, dst_pos):
|
|
self.__lines = []
|
|
self.__src_pos = int(src_pos)
|
|
self.__dst_pos = int(dst_pos)
|
|
def src_start(self):
|
|
return self.__src_pos
|
|
def add_line(self,line):
|
|
self.__lines.append(line)
|
|
def src(self):
|
|
src = []
|
|
for line in self.__lines:
|
|
if line.is_src():
|
|
src.append(line)
|
|
return src
|
|
def dst(self):
|
|
dst = []
|
|
for line in self.__lines:
|
|
if line.is_dst():
|
|
dst.append(line)
|
|
return dst
|
|
def src_len(self):
|
|
return len(self.src())
|
|
def dst_len(self):
|
|
return len(self.dst())
|
|
def write(self,f):
|
|
f.write('@@ -%d,%d +%d,%d @@\n' % (self.__src_pos, self.src_len(),
|
|
self.__dst_pos, self.dst_len()))
|
|
for line in self.__lines:
|
|
line.write(f)
|
|
|
|
class Patch:
|
|
def __init__(self):
|
|
self.__src = ''
|
|
self.__dst = ''
|
|
self.__chunks = []
|
|
def add_chunk(self, chunk):
|
|
self.__chunks.append(chunk)
|
|
def chunks(self):
|
|
return self.__chunks
|
|
def set_src(self,src):
|
|
self.__src = src
|
|
def set_dst(self,dst):
|
|
self.__dst = dst
|
|
def apply(self,filename):
|
|
# XXX: not implemented
|
|
return
|
|
def write(self,f):
|
|
f.write('--- %s\n' % self.__src )
|
|
f.write('+++ %s\n' % self.__dst )
|
|
for chunk in self.__chunks:
|
|
chunk.write(f)
|
|
|
|
def parse_patchset(generator):
|
|
src_file = re.compile('^--- (.*)$')
|
|
dst_file = re.compile('^\+\+\+ (.*)$')
|
|
chunk_start = re.compile('^@@ -([0-9]+),([0-9]+) \+([0-9]+),([0-9]+) @@')
|
|
src = re.compile('^-(.*)$')
|
|
dst = re.compile('^\+(.*)$')
|
|
both = re.compile('^ (.*)$')
|
|
patchset = []
|
|
current_patch = None
|
|
for line in generator:
|
|
m = src_file.search(line)
|
|
if m is not None:
|
|
current_patch = Patch()
|
|
patchset.append(current_patch)
|
|
current_patch.set_src(m.group(1))
|
|
continue
|
|
m = dst_file.search(line)
|
|
if m is not None:
|
|
current_patch.set_dst(m.group(1))
|
|
continue
|
|
m = chunk_start.search(line)
|
|
if m is not None:
|
|
current_chunk = PatchChunk(m.group(1), m.group(3))
|
|
current_patch.add_chunk(current_chunk)
|
|
continue
|
|
m = src.search(line)
|
|
if m is not None:
|
|
l = PatchChunkLine()
|
|
l.set_src(m.group(1))
|
|
current_chunk.add_line(l)
|
|
continue
|
|
m = dst.search(line)
|
|
if m is not None:
|
|
l = PatchChunkLine()
|
|
l.set_dst(m.group(1))
|
|
current_chunk.add_line(l)
|
|
continue
|
|
m = both.search(line)
|
|
if m is not None:
|
|
l = PatchChunkLine()
|
|
l.set_both(m.group(1))
|
|
current_chunk.add_line(l)
|
|
continue
|
|
raise Exception()
|
|
return patchset
|
|
|
|
def remove_trailing_whitespace_changes(patch_generator):
|
|
whitespace = re.compile('^(.*)([ \t]+)$')
|
|
patchset = parse_patchset(patch_generator)
|
|
for patch in patchset:
|
|
for chunk in patch.chunks():
|
|
src = chunk.src()
|
|
dst = chunk.dst()
|
|
try:
|
|
for i in range(0,len(src)):
|
|
s = src[i]
|
|
d = dst[i]
|
|
m = whitespace.search(s.line())
|
|
if m is not None and m.group(1) == d.line():
|
|
d.append_to_line(m.group(2))
|
|
except:
|
|
return patchset
|
|
return patchset
|
|
|
|
|
|
def indent(source, debug, level):
|
|
output = tempfile.mkstemp()[1]
|
|
# apply uncrustify
|
|
cfg = uncrustify_config_file(level)
|
|
if debug:
|
|
sys.stderr.write('original file=' + source + '\n')
|
|
sys.stderr.write('uncrustify config file=' + cfg + '\n')
|
|
sys.stderr.write('temporary file=' + output + '\n')
|
|
try:
|
|
uncrust = subprocess.Popen(['uncrustify', '-c', cfg, '-f', source, '-o', output],
|
|
stdin = subprocess.PIPE,
|
|
stdout = subprocess.PIPE,
|
|
stderr = subprocess.PIPE)
|
|
(out, err) = uncrust.communicate('')
|
|
if debug:
|
|
sys.stderr.write(out)
|
|
sys.stderr.write(err)
|
|
except OSError:
|
|
raise Exception ('uncrustify not installed')
|
|
# generate a diff file
|
|
src = open(source, 'r')
|
|
dst = open(output, 'r')
|
|
diff = difflib.unified_diff(src.readlines(), dst.readlines(),
|
|
fromfile=source, tofile=output)
|
|
src.close()
|
|
dst.close()
|
|
if debug:
|
|
initial_diff = tempfile.mkstemp()[1]
|
|
sys.stderr.write('initial diff file=' + initial_diff + '\n')
|
|
tmp = open(initial_diff, 'w')
|
|
tmp.writelines(diff)
|
|
tmp.close()
|
|
final_diff = tempfile.mkstemp()[1]
|
|
if level < 3:
|
|
patchset = remove_trailing_whitespace_changes(diff);
|
|
dst = open(final_diff, 'w')
|
|
if len(patchset) != 0:
|
|
patchset[0].write(dst)
|
|
dst.close()
|
|
else:
|
|
dst = open(final_diff, 'w')
|
|
dst.writelines(diff)
|
|
dst.close()
|
|
|
|
|
|
# apply diff file
|
|
if debug:
|
|
sys.stderr.write('final diff file=' + final_diff + '\n')
|
|
shutil.copyfile(source,output)
|
|
patch = subprocess.Popen(['patch', '-p1', '-i', final_diff, output],
|
|
stdin = subprocess.PIPE,
|
|
stdout = subprocess.PIPE,
|
|
stderr = subprocess.PIPE)
|
|
(out, err) = patch.communicate('')
|
|
if debug:
|
|
sys.stderr.write(out)
|
|
sys.stderr.write(err)
|
|
return output
|
|
|
|
|
|
|
|
def indent_files(files, diff=False, debug=False, level=0, inplace=False):
|
|
output = []
|
|
for f in files:
|
|
dst = indent(f, debug=debug, level=level)
|
|
output.append([f,dst])
|
|
|
|
# First, copy to inplace
|
|
if inplace:
|
|
for src,dst in output:
|
|
shutil.copyfile(dst,src)
|
|
return True
|
|
|
|
# now, compare
|
|
failed = []
|
|
for src,dst in output:
|
|
if filecmp.cmp(src,dst) == 0:
|
|
failed.append([src, dst])
|
|
if len(failed) > 0:
|
|
if not diff:
|
|
print 'Found %u badly indented files:' % len(failed)
|
|
for src,dst in failed:
|
|
print ' ' + src
|
|
else:
|
|
for src,dst in failed:
|
|
s = open(src, 'r').readlines()
|
|
d = open(dst, 'r').readlines()
|
|
for line in difflib.unified_diff(s, d, fromfile=src, tofile=dst):
|
|
sys.stdout.write(line)
|
|
return False
|
|
return True
|
|
|
|
def run_as_hg_hook(ui, repo, **kwargs):
|
|
# hack to work around mercurial < 1.3 bug
|
|
from mercurial import lock, error
|
|
lock.LockError = error.LockError
|
|
# actually do the work
|
|
files = hg_modified_files()
|
|
if not indent_files(files, inplace=False):
|
|
return True
|
|
return False
|
|
|
|
def run_as_main():
|
|
parser = optparse.OptionParser()
|
|
parser.add_option('--debug', action='store_true', dest='debug', default=False,
|
|
help='Output some debugging information')
|
|
parser.add_option('-l', '--level', type='int', dest='level', default=0,
|
|
help="Level of style conformance: higher levels include all lower levels. "
|
|
"level=0: re-indent only. level=1: add extra spaces. level=2: insert extra newlines and "
|
|
"extra braces around single-line statements. level=3: remove all trailing spaces")
|
|
parser.add_option('--check-hg-hook', action='store_true', dest='hg_hook', default=False,
|
|
help='Get the list of files to check from mercurial\'s list of modified '
|
|
'and added files and assume that the script runs as a pretxncommit mercurial hook')
|
|
parser.add_option('--check-hg', action='store_true', dest='hg', default=False,
|
|
help="Get the list of files to check from mercurial\'s list of modified and added files")
|
|
parser.add_option('-f', '--check-file', action='store', dest='file', default='',
|
|
help="Check a single file")
|
|
parser.add_option('--diff', action='store_true', dest='diff', default=False,
|
|
help="Generate a diff on stdout of the indented files")
|
|
parser.add_option('-i', '--in-place', action='store_true', dest='in_place', default=False,
|
|
help="Indent the input files in-place")
|
|
(options,args) = parser.parse_args()
|
|
debug = options.debug
|
|
if options.hg_hook:
|
|
files = hg_modified_files()
|
|
if not indent_files(files, debug=options.debug,
|
|
level=options.level,
|
|
inplace=False):
|
|
sys.exit(1)
|
|
elif options.hg:
|
|
files = hg_modified_files()
|
|
indent_files(files, diff=options.diff,
|
|
debug=options.debug,
|
|
level=options.level,
|
|
inplace=options.in_place)
|
|
elif options.file != '':
|
|
file = options.file
|
|
if not os.path.exists(file) or \
|
|
not os.path.isfile(file):
|
|
print 'file %s does not exist' % file
|
|
sys.exit(1)
|
|
indent_files([file], diff=options.diff,
|
|
debug=options.debug,
|
|
level=options.level,
|
|
inplace=options.in_place)
|
|
sys.exit(0)
|
|
|
|
if __name__ == '__main__':
|
|
# try:
|
|
run_as_main()
|
|
# except Exception, e:
|
|
# sys.stderr.write(str(e) + '\n')
|
|
# sys.exit(1)
|