Last active
October 24, 2017 19:52
-
-
Save CDanU/54446524c8919b1d490147f6c8165bb6 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#!/bin/python | |
from __future__ import print_function # python >= 2.6 | |
import glob | |
from os import chdir, listdir, makedirs, path, name as os_name, \ | |
linesep as os_linesep, sep as os_sep | |
from subprocess import Popen, PIPE, call | |
from sys import exit as sys_exit, stderr | |
from pprint import pprint | |
from threading import Timer | |
def term_proc(proc, timeout): | |
timeout["value"] = True | |
proc.terminate() | |
def proc_output(args, timeout_sec=None): | |
proc = Popen(args, stdout=PIPE, stderr=PIPE) | |
timeout = {"value": False} | |
if timeout_sec is not None: | |
timeout = {"value": False} | |
timer = Timer(timeout_sec, term_proc, [proc, timeout]) | |
timer.start() | |
output_b, error_txt_b = proc.communicate() | |
if timeout_sec is not None: | |
timer.cancel() | |
output = output_b.decode("UTF-8") | |
error = error_txt_b.decode("UTF-8") | |
if error: | |
print("proc stderr:\n%s" % error, file=stderr) | |
if timeout["value"]: | |
print("proc timeout:\n%s" % ' '.join(args), file=stderr) | |
return output if proc.returncode == 0 and not timeout["value"] else None | |
def main(): | |
root_dir = path.dirname(path.dirname(path.abspath(__file__))) | |
test_dir = path.join(root_dir, "tests") | |
config_dir = path.join(test_dir, "config") | |
input_dir = path.join(test_dir, "input") | |
output_dir = path.join(test_dir, "output") | |
chdir(test_dir) | |
files = glob.glob('./*.test') | |
config_map = {} | |
for test_file in files: | |
rg_string = proc_output(["grep", "-P", ".cfg", test_file]) | |
if rg_string is None: | |
continue | |
lines = rg_string.splitlines() | |
for line in lines: | |
line = line.strip() | |
splits = line.split() | |
split_len = len(splits) | |
idx = splits[0] | |
if idx[-1] == '!': | |
idx = idx[:-1] | |
cfg = splits[1] | |
file_path = splits[2] | |
lang = None if split_len < 4 else splits[3] | |
if line[0] == '#': | |
continue | |
lang_dir, file = file_path.split('/', 1) | |
if cfg not in config_map: | |
config_map[cfg] = [(idx, file, lang_dir, lang)] | |
else: | |
config_map[cfg].append((idx, file, lang_dir, lang)) | |
for key, value_list in config_map.items(): | |
config_file_path = path.join(config_dir, key) | |
args = ["python", "../scripts/option_reducer.py", '-q', | |
'-b', "../build/uncrustify", | |
"-c", config_file_path] | |
for value_pair in value_list: | |
input_file_path = path.join(input_dir, "%s/%s" | |
% (value_pair[2], value_pair[1])) | |
args.append("-i") | |
args.append(input_file_path) | |
output_file_path = path.join(output_dir, "%s/%s-%s" | |
% (value_pair[2], value_pair[0], | |
value_pair[1])) | |
args.append("-f") | |
args.append(output_file_path) | |
if len(value_pair) > 4: | |
args.append("-l") | |
args.append(value_pair[3]) | |
print("\n%s" % config_file_path, flush=True) | |
print("_" * 80, flush=True) | |
out = proc_output(args) | |
# out = None | |
if out is None: | |
continue | |
with open(config_file_path, 'w') as f: | |
f.write(out) | |
return 0 | |
if __name__ == "__main__": | |
sys_exit(main()) |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#!/bin/python | |
""" | |
option_reducer.py | |
reduces options in a given config file to the minimum while still maintaining | |
desired formatting | |
:author: Daniel Chumak | |
:license: GPL v2+ | |
""" | |
# Possible improvements: | |
# - parallelize add_back() | |
# - (maybe) reduce amount of written config file, see Uncrustify --set | |
from __future__ import print_function # python >= 2.6 | |
import argparse | |
from os import name as os_name, sep as os_path_sep, fdopen as os_fdopen, \ | |
remove as os_remove | |
from os.path import exists, join as path_join | |
from subprocess import Popen, PIPE | |
from sys import exit as sys_exit, stderr, stdout | |
from shutil import rmtree | |
from multiprocessing import cpu_count | |
from tempfile import mkdtemp, mkstemp | |
from contextlib import contextmanager | |
from collections import OrderedDict | |
from threading import Timer | |
from multiprocessing.pool import Pool | |
from itertools import combinations | |
FLAGS = None | |
NULL_DEV = "/dev/null" if os_name != "nt" else "nul" | |
def enum(**enums): | |
return type('Enum', (), enums) | |
RESTULTSFLAG = enum(NONE=0, REMOVE=1, KEEP=2) | |
ERROR_CODE = enum(NONE=0, FLAGS=200, SANITY0=201, SANITY1=202) | |
MODES = ("reduce", "no-default") | |
@contextmanager | |
def make_temp_directory(): | |
""" | |
Wraps tempfile.mkdtemp to use it inside a with statement that auto deletes | |
the temporary directory with its content after the with block closes | |
:return: str | |
---------------------------------------------------------------------------- | |
path to the generated directory | |
""" | |
temp_dir = mkdtemp() | |
try: | |
yield temp_dir | |
finally: | |
rmtree(temp_dir) | |
@contextmanager | |
def make_raw_temp_file(*args, **kwargs): | |
""" | |
Wraps tempfile.mkstemp to use it inside a with statement that auto deletes | |
the file after the with block closes | |
Parameters | |
---------------------------------------------------------------------------- | |
:param args, kwargs: | |
arguments passed to mkstemp | |
:return: int, str | |
---------------------------------------------------------------------------- | |
the file descriptor and the file path of the created temporary file | |
""" | |
fd, tmp_file_name = mkstemp(*args, **kwargs) | |
try: | |
yield (fd, tmp_file_name) | |
finally: | |
os_remove(tmp_file_name) | |
@contextmanager | |
def open_fd(*args, **kwargs): | |
""" | |
Wraps os.fdopen to use it inside a with statement that auto closes the | |
generated file descriptor after the with block closes | |
Parameters | |
---------------------------------------------------------------------------- | |
:param args, kwargs: | |
arguments passed to os.fdopen | |
:return: TextIOWrapper | |
---------------------------------------------------------------------------- | |
open file object connected to the file descriptor | |
""" | |
fp = os_fdopen(*args, **kwargs) | |
try: | |
yield fp | |
finally: | |
fp.close() | |
def term_proc(proc, timeout): | |
""" | |
helper function to terminate a process | |
Parameters | |
---------------------------------------------------------------------------- | |
:param proc: process object | |
the process object that is going to be terminated | |
:param timeout: dictionary | |
a dictionary (used as object reference) to set a flag that indicates | |
that the process is going to be terminated | |
""" | |
timeout["value"] = True | |
proc.terminate() | |
def uncrustify(unc_bin_path, cfg_file_path, unformatted_file_path, | |
lang=None, debug_file=None, check=False): | |
""" | |
executes Uncrustify and captures its stdout | |
Parameters | |
---------------------------------------------------------------------------- | |
:param unc_bin_path: str | |
path to the Uncrustify binary | |
:param cfg_file_path: str | |
path to a config file for Uncrustify | |
:param unformatted_file_path: str | |
path to a file that is going to be formatted | |
:param lang: str / None | |
Uncrustifys -l argument | |
:param debug_file: str / None | |
Uncrustifys -p argument | |
:param check: bool | |
Used to control whether Uncrustifys --check is going to be used | |
:return: str / None | |
---------------------------------------------------------------------------- | |
returns the stdout from Uncrustify or None if the process takes to much | |
time (set to 5 sec) | |
""" | |
args = [unc_bin_path, "-q", "-c", cfg_file_path, '-f', | |
unformatted_file_path] | |
if lang: | |
args.extend(("-l", lang)) | |
if debug_file: | |
args.extend(('-p', debug_file)) | |
if check: | |
args.append('--check') | |
proc = Popen(args, stdout=PIPE, stderr=PIPE) | |
timeout = {"value": False} | |
timer = Timer(5, term_proc, [proc, timeout]) | |
timer.start() | |
output_b, error_txt_b = proc.communicate() | |
timer.cancel() | |
if timeout["value"]: | |
print("uncrustify proc timeout: %s" % ' '.join(args), file=stderr) | |
return None | |
error = error_txt_b.decode("UTF-8") | |
if error: | |
print("Uncrustify %s stderr:\n %s" % (unformatted_file_path, error), | |
file=stderr) | |
return output_b | |
def same_expected_generated(formatted_path, unc_bin_path, cfg_file_path, | |
input_path, lang=None): | |
""" | |
Calls uncrustify and compares its generated output with the content of a | |
file | |
Parameters | |
---------------------------------------------------------------------------- | |
:param formatted_path: str | |
path to a file containing the expected content | |
:params unc_bin_path, cfg_file_path, input_path, lang: str, str, str, | |
str / None | |
see uncrustify() | |
:return: bool | |
---------------------------------------------------------------------------- | |
True if the strings match, False otherwise | |
""" | |
expected_string = '' | |
with open(formatted_path, 'rb') as f: | |
expected_string = f.read() | |
formatted_string = uncrustify(unc_bin_path, cfg_file_path, input_path, lang) | |
return True if formatted_string == expected_string else False | |
def process_uncrustify(args): | |
""" | |
special wrapper for same_expected_generated() | |
accesses global var(s): RESTULTSFLAG | |
Parameters | |
---------------------------------------------------------------------------- | |
:param args: list / tuple< int, ... > | |
this function is intended to be called by multiprocessing.pool.map() | |
therefore all arguments are inside a list / tuple: | |
id: int | |
an index number needed by the caller to differentiate runs | |
other parameters: | |
see same_expected_generated() | |
:return: tuple< int, RESTULTSFLAG > | |
---------------------------------------------------------------------------- | |
returns a tuple containing the id and a RESTULTSFLAG, REMOVE if both | |
strings are equal, KEEP if not | |
""" | |
id = args[0] | |
res = same_expected_generated(*args[1:]) | |
return id, RESTULTSFLAG.REMOVE if res else RESTULTSFLAG.KEEP | |
def write_config_file(args): | |
""" | |
Writes all but one excluded option into a config file | |
Parameters | |
---------------------------------------------------------------------------- | |
:param args: list / tuple< list< tuple< str, str > >, str, int > | |
this function is intended to be called by multiprocessing.pool.map() | |
therefore all arguments are inside a list / tuple: | |
config_list: list< tuple< str, str > > | |
a list of tuples containing option names and values | |
tmp_dir: str | |
path to a directory in which the config file is going to be | |
written | |
exclude_idx: int | |
index for an option that is not going to be written into the | |
config file | |
""" | |
config_list, tmp_dir, exclude_idx = args | |
with open("%s%suncr-%d.cfg" % (tmp_dir, os_path_sep, exclude_idx), | |
'w') as f: | |
print_config(config_list, target_file_obj=f, exclude_idx=exclude_idx) | |
def write_config_file2(args): | |
""" | |
Writes two option lists into a config file | |
Parameters | |
---------------------------------------------------------------------------- | |
:param args: list< tuple< str, str > >, | |
list< tuple< str, str > >, str, int | |
this function is intended to be called by multiprocessing.pool.map() | |
therefore all arguments are inside a list / tuple: | |
config_list: list< tuple< str, str > > | |
the first list of tuples containing option names and values | |
test_list: list< tuple< str, str > > | |
the second list of tuples containing option names and values | |
tmp_dir: str | |
path to a directory in which the config file is going to be | |
written | |
idx: int | |
index that is going to be used for the filename | |
""" | |
config_list0, config_list1, tmp_dir, idx = args | |
with open("%s%suncr-r-%d.cfg" % (tmp_dir, os_path_sep, idx), 'w') as f: | |
print_config(config_list0, target_file_obj=f) | |
print("", end='\n', file=f) | |
print_config(config_list1, target_file_obj=f) | |
def gen_multi_combinations(elements, N): | |
""" | |
generator function that generates, based on a set of elements, all | |
combinations of 1..N elements | |
Parameters | |
---------------------------------------------------------------------------- | |
:param elements: list / tuple | |
a list of elements from which the combinations will be generated | |
:param N: | |
the max number of element in a combination | |
:return: list | |
---------------------------------------------------------------------------- | |
yields a single combination of the elements | |
>>> gen_multi_combinations(["a", "b", "c"], 3) | |
(a); (b); (c); (a,b); (a,c); (b,c); (a,b,c) | |
""" | |
fields = len(elements) | |
if N > fields: | |
raise Exception("Error: N > len(options)") | |
if N <= 0: | |
raise Exception("Error: N <= 0") | |
for n in range(1, N + 1): | |
yield combinations(elements, n) | |
def add_back(unc_bin_path, input_files, formatted_files, langs, options_r, | |
options_k, tmp_dir): | |
""" | |
lets Uncrustify format files with generated configs files until all | |
formatted files match their according expected files. | |
Multiple config files are generated based on a (base) list of Uncrustify | |
options combined with additional (new) options derived from combinations of | |
another list of options. | |
accesses global var(s): RESTULTSFLAG | |
Parameters | |
---------------------------------------------------------------------------- | |
:param unc_bin_path: str | |
path to the Uncrustify binary | |
:param input_files: list / tuple< str > | |
a list containing paths to a files that are going to be formatted | |
:param formatted_files: list / tuple< str > | |
a list containing paths to files containing the expected contents | |
:param langs: list / tuple< str > / None | |
a list of languages the files, used as Uncrustifys -l argument | |
can be None or shorter than the amount of provided files | |
:param options_r: list< tuple< str, str > > | |
the list of options from which combinations will be derived | |
:param options_k: list< tuple< str, str > > | |
the (base) list of Uncrustify options | |
:param tmp_dir: str | |
the directory in which the config files will be written to | |
:return: list< tuple< str, str > > / None | |
---------------------------------------------------------------------------- | |
list of additional option that were needed to generate matching file | |
contents | |
""" | |
lang_max_idx = -1 if langs is None else len(langs) - 1 | |
file_len = len(input_files) | |
if len(formatted_files) != file_len: | |
raise Exception("len(input_files) != len(formatted_files)") | |
for m_combination in gen_multi_combinations(options_r, len(options_r)): | |
for idx, (r_combination) in enumerate(m_combination): | |
write_config_file2((options_k, r_combination, tmp_dir, idx)) | |
cfg_file_path = "%s%suncr-r-%d.cfg" % (tmp_dir, os_path_sep, idx) | |
res = [] | |
for file_idx in range(file_len): | |
lang = None if idx > lang_max_idx else langs[file_idx] | |
r = process_uncrustify( | |
(0, formatted_files[file_idx], unc_bin_path, cfg_file_path, | |
input_files[file_idx], lang)) | |
res.append(r[1]) | |
# all files, flag = remove -> option can be removed -> equal output | |
if res.count(RESTULTSFLAG.REMOVE) == len(res): | |
return r_combination | |
return None | |
def sanity_raw_run(args): | |
""" | |
wrapper for same_expected_generated(), prints error message if the config | |
file does not generate the expected result | |
Parameters | |
---------------------------------------------------------------------------- | |
:param args: | |
see same_expected_generated | |
:return: | |
---------------------------------------------------------------------------- | |
see same_expected_generated | |
""" | |
res = same_expected_generated(*args) | |
if not res: | |
formatted_file_path = args[0] | |
config_file_path = args[2] | |
input_file_path = args[3] | |
print("\nprovided config does not create formatted source file:\n" | |
" %s\n %s\n->| %s" | |
% (input_file_path, config_file_path, formatted_file_path), | |
file=stderr) | |
return res | |
def sanity_run(args): | |
""" | |
wrapper for same_expected_generated(), prints error message if the config | |
file does not generate the expected result | |
Parameters | |
---------------------------------------------------------------------------- | |
:param args: | |
see same_expected_generated | |
:return: | |
---------------------------------------------------------------------------- | |
see same_expected_generated | |
""" | |
res = same_expected_generated(*args) | |
if not res: | |
formatted_file_path = args[0] | |
input_file_path = args[3] | |
print("\ngenerated config does not create formatted source file:\n" | |
" %s\n %s" | |
% (input_file_path, formatted_file_path), file=stderr) | |
return res | |
def sanity_run_splitter(uncr_bin, config_list, input_files, formatted_files, | |
langs, tmp_dir, jobs): | |
""" | |
writes config option into a file and tests if every input file is formatted | |
so that is matches the content of the according expected file | |
Parameters | |
---------------------------------------------------------------------------- | |
:param uncr_bin: str | |
path to the Uncrustify binary | |
:param config_list: list< tuple< str, str > > | |
a list of tuples containing option names and values | |
:param input_files: list / tuple< str > | |
a list containing paths to a files that are going to be formatted | |
:param formatted_files: list / tuple< str > | |
a list containing paths to files containing the expected contents | |
:param langs: list / tuple< str > / None | |
a list of languages the files, used as Uncrustifys -l argument | |
can be None or shorter than the amount of provided files | |
:param tmp_dir: str | |
the directory in which the config files will be written to | |
:param jobs: int | |
number of processes to use | |
:return: bool | |
---------------------------------------------------------------------------- | |
True if all files generate correct results, False oterhwise | |
""" | |
file_len = len(input_files) | |
if len(formatted_files) != file_len: | |
raise Exception("len(input_files) != len(formatted_files)") | |
gen_cfg_path = path_join(tmp_dir, "gen.cfg") | |
with open(gen_cfg_path, 'w') as f: | |
print_config(config_list, target_file_obj=f) | |
lang_max_idx = -1 if langs is None else len(langs) - 1 | |
args = [] | |
for idx in range(file_len): | |
lang = None if idx > lang_max_idx else langs[idx] | |
args.append((formatted_files[idx], uncr_bin, gen_cfg_path, | |
input_files[idx], lang)) | |
pool = Pool(processes=jobs) | |
sr = pool.map(sanity_run, args) | |
return False not in sr | |
def print_config(config_list, target_file_obj=stdout, exclude_idx=()): | |
""" | |
prints config options into a config file | |
Parameters | |
---------------------------------------------------------------------------- | |
:param config_list: list< tuple< str, str > > | |
a list containing pairs of option names and option values | |
:param target_file_obj: file object | |
see file param of print() | |
:param exclude_idx: int / list< int > | |
index of option(s) that are not going to be printed | |
""" | |
if not config_list: | |
return | |
config_list_len = len(config_list) | |
# check if exclude_idx list is empty -> assign len | |
if type(exclude_idx) in (list, tuple) and not exclude_idx: | |
exclude_idx = [config_list_len] | |
else: | |
# sort it, unless it is an int -> transform into a list | |
try: | |
exclude_idx = sorted(exclude_idx) | |
except TypeError: | |
exclude_idx = [exclude_idx] | |
# extracted first loop round: | |
# do not print '\n' for the ( here non-existing) previous line | |
if exclude_idx[0] != 0: | |
print("%s = %s" % (config_list[0][0].ljust(31, ' '), config_list[0][1]), | |
end='', file=target_file_obj) | |
# also print space if a single option was provided and it is going to be | |
# excluded. This is done in order to be able to differentiate between | |
# --empty-nochange and the case where all options can be removed | |
elif config_list_len == 1: | |
print(' ', end='', file=target_file_obj) | |
return | |
start_idx = 1 | |
for end in exclude_idx: | |
end = min(end, config_list_len) | |
for idx in range(start_idx, end): | |
print("\n%s = %s" | |
% (config_list[idx][0].ljust(31, ' '), config_list[idx][1]), | |
end='', file=target_file_obj) | |
start_idx = min(end + 1, config_list_len) | |
# after | |
for idx in range(start_idx, config_list_len): | |
print("\n%s = %s" | |
% (config_list[idx][0].ljust(31, ' '), config_list[idx][1]), | |
end='', file=target_file_obj) | |
def get_non_default_options(unc_bin_path, cfg_file_path): | |
""" | |
calls Uncrustify to generate a debug file from which a config only with | |
non default valued options are extracted | |
accesses global var(s): NULL_DEV | |
Parameters | |
---------------------------------------------------------------------------- | |
:param unc_bin_path: str | |
path to the Uncrustify binary | |
:param cfg_file_path: str | |
path to a config file for Uncrustify | |
:return: list< str > | |
---------------------------------------------------------------------------- | |
amount of lines in the provided and shortened config | |
""" | |
lines = [] | |
with make_raw_temp_file(suffix='.unc') as (fd, file_path): | |
# make debug file | |
uncrustify(unc_bin_path, cfg_file_path, NULL_DEV, debug_file=file_path, | |
check=True) | |
# extract non comment lines -> non default config lines | |
with open_fd(fd, 'r') as fp: | |
lines = fp.read().splitlines() | |
lines = [line for line in lines if not line[:1] == '#'] | |
return lines | |
def parse_config_file(file_obj): | |
""" | |
Reads in a Uncrustify config file | |
Parameters | |
---------------------------------------------------------------------------- | |
:param file_obj: | |
the file object of an opened config file | |
:return: list< tuple< str, str > > | |
---------------------------------------------------------------------------- | |
a list containing pairs of option names and option values | |
""" | |
# dict used to only save the last option setting if the same option occurs | |
# multiple times, without this: | |
# optionA0 can be removed because optionA1 = s0, and | |
# optionA1 can be removed because optionA0 = s0 | |
# -> optionA0, optionA1 are both removed | |
config_map = OrderedDict() | |
# special keys may not have this limitation, as for example | |
# 'set x y' and 'set x z' do not overwrite each other | |
special_keys = {'macro-open', 'macro-else', 'macro-close', 'set', 'type', | |
'file_ext', 'define'} | |
special_list = [] | |
for line in file_obj: | |
# cut comments | |
pound_pos = line.find('#') | |
if pound_pos != -1: | |
line = line[:pound_pos] | |
split_pos = line.find('=') | |
if split_pos == -1: | |
split_pos = line.find(' ') | |
if split_pos == -1: | |
continue | |
key = line[:split_pos].strip() | |
value = line[split_pos + 1:].strip() | |
if key in special_keys: | |
special_list.append((key, value)) | |
else: | |
config_map[key] = value | |
config_list = list(config_map.items()) | |
config_list += special_list | |
return config_list | |
def count_lines(file_path): | |
""" | |
returns the count of lines in a file by counting '\n' chars | |
Parameters | |
---------------------------------------------------------------------------- | |
:param file_path: str | |
file in which the lines will be counted | |
:return: int | |
---------------------------------------------------------------------------- | |
number a lines | |
""" | |
in_count = 0 | |
with open(file_path, 'r') as f: | |
in_count = f.read().count('\n') + 1 | |
return in_count | |
def reduce(options_list): | |
""" | |
Reduces the given options to a minimum | |
accesses global var(s): FLAGS, RESTULTSFLAG, ERROR_CODE | |
Parameters | |
---------------------------------------------------------------------------- | |
:param options_list: list< tuple< str, str > > | |
the list of options that are going to be reduced | |
:return: int, list< tuple< str, str > > | |
status return code, reduced options | |
""" | |
config_list_len = len(options_list) | |
ret_flag = 0 | |
file_count = len(FLAGS.input_file_path) | |
lang_max_idx = -1 if FLAGS.lang is None else len(FLAGS.lang) - 1 | |
pool = Pool(processes=FLAGS.jobs) | |
with make_temp_directory() as tmp_dir: | |
# region sanity run ---------------------------------------------------- | |
args = [] | |
for idx in range(file_count): | |
lang = None if idx > lang_max_idx else FLAGS.lang[idx] | |
args.append((FLAGS.formatted_file_path[idx], | |
FLAGS.uncrustify_binary_path, FLAGS.config_file_path, | |
FLAGS.input_file_path[idx], lang)) | |
sr = pool.map(sanity_raw_run, args) | |
del args[:] | |
if False in sr: | |
return ERROR_CODE.SANITY0, [] | |
del sr[:] | |
# endregion | |
# region config generator loop ----------------------------------------- | |
args = [] | |
for e_idx in range(config_list_len): | |
args.append((options_list, tmp_dir, e_idx)) | |
pool.map(write_config_file, args) | |
del args[:] | |
# endregion | |
# region main loop ----------------------------------------------------- | |
args = [] | |
jobs = config_list_len * file_count | |
for idx in range(jobs): | |
file_idx = idx // config_list_len | |
option_idx = idx % config_list_len | |
cfg_file_path = "%s%suncr-%d.cfg" \ | |
% (tmp_dir, os_path_sep, option_idx) | |
lang = None if idx > lang_max_idx else FLAGS.lang[file_idx] | |
args.append((idx, FLAGS.formatted_file_path[file_idx], | |
FLAGS.uncrustify_binary_path, cfg_file_path, | |
FLAGS.input_file_path[file_idx], lang)) | |
results = pool.map(process_uncrustify, args) | |
del args[:] | |
# endregion | |
# region clean results ------------------------------------------------- | |
option_flags = [RESTULTSFLAG.NONE] * config_list_len | |
for r in results: | |
idx = r[0] | |
flag = r[1] | |
option_idx = idx % config_list_len | |
if option_flags[option_idx] == RESTULTSFLAG.KEEP: | |
continue | |
option_flags[option_idx] = flag | |
del results[:] | |
# endregion | |
options_r = [options_list[idx] for idx, x in enumerate(option_flags) | |
if x == RESTULTSFLAG.REMOVE] | |
options_list = [options_list[idx] for idx, x in enumerate(option_flags) | |
if x == RESTULTSFLAG.KEEP] | |
del option_flags[:] | |
# region sanity run ---------------------------------------------------- | |
# options can be removed one at a time generating appropriate results, | |
# oddly enough sometimes a config generated this way can fail when a | |
# combination of multiple options is missing | |
s_flag = True | |
if options_r: | |
s_flag = sanity_run_splitter( | |
FLAGS.uncrustify_binary_path, options_list, | |
FLAGS.input_file_path, FLAGS.formatted_file_path, FLAGS.lang, | |
tmp_dir, FLAGS.jobs) | |
if not s_flag: | |
ret_flag = ERROR_CODE.SANITY1 | |
print("\n\nstumbled upon complex option dependencies in \n" | |
" %s\n" | |
"trying to add back minimal amount of removed options\n" | |
% FLAGS.config_file_path, file=stderr) | |
ret_options = add_back( | |
FLAGS.uncrustify_binary_path, FLAGS.input_file_path, | |
FLAGS.formatted_file_path, FLAGS.lang, options_r, | |
options_list, tmp_dir) | |
if ret_options: | |
options_list.extend(ret_options) | |
s_flag = sanity_run_splitter( | |
FLAGS.uncrustify_binary_path, options_list, | |
FLAGS.input_file_path, FLAGS.formatted_file_path, | |
FLAGS.lang, tmp_dir, FLAGS.jobs) | |
if s_flag: | |
print("Success!", file=stderr) | |
ret_flag = 0 | |
# endregion | |
return ret_flag, options_list if ret_flag == 0 else [] | |
def reduce_mode(): | |
""" | |
the mode that minimizes a config file as much as possible | |
accesses global var(s): FLAGS, ERROR_CODE | |
""" | |
ret_flag = 0 | |
option_list = {} | |
# gen & parse non default config | |
lines = get_non_default_options(FLAGS.uncrustify_binary_path, | |
FLAGS.config_file_path) | |
option_list = parse_config_file(lines) | |
config_list_len = len(option_list) | |
config_lines_init = count_lines(FLAGS.config_file_path) | |
config_lines_ndef = len(lines) | |
del lines[:] | |
# early return if all options are already removed at this point | |
if config_list_len == 0: | |
if not FLAGS.empty_nochange \ | |
or (config_lines_init - config_lines_ndef) > 0: | |
if not FLAGS.quiet: | |
print("\n%s" % '# '.ljust(78, '-')) | |
print(" ") | |
if not FLAGS.quiet: | |
print("%s" % '# '.ljust(78, '-')) | |
print("# initial config lines: %d,\n" | |
"# default options and unneeded lines: %d,\n" | |
"# unneeded options: 0,\n" | |
"# kept options: 0" | |
% (config_lines_init, config_lines_init)) | |
print("ret_flag: 0", file=stderr) | |
return ERROR_CODE.NONE | |
# gen reduced options | |
config_lines_redu = -1 | |
for i in range(FLAGS.passes): | |
old_config_lines_redu = config_lines_redu | |
ret_flag, option_list = reduce(option_list) | |
config_lines_redu = len(option_list) | |
if ret_flag != ERROR_CODE.NONE \ | |
or config_lines_redu == old_config_lines_redu: | |
break | |
# print output + stats | |
if ret_flag == 0 and (not FLAGS.empty_nochange | |
or config_lines_ndef != config_lines_redu): | |
if not FLAGS.quiet: | |
print("\n%s" % '# '.ljust(78, '-')) | |
print_config(option_list) | |
if not FLAGS.quiet: | |
print("\n%s" % '# '.ljust(78, '-')) | |
print("# initial config lines: %d,\n" | |
"# default options and unneeded lines: %d,\n" | |
"# unneeded options: %d,\n" | |
"# kept options: %d" | |
% (config_lines_init, | |
config_lines_init - config_lines_ndef, | |
config_lines_ndef - config_lines_redu, | |
config_lines_redu)) | |
print("ret_flag: %d" % ret_flag, file=stderr) | |
return ret_flag | |
def no_default_mode(): | |
""" | |
the mode removes all unnecessary lines and options with default values | |
accesses global var(s): FLAGS, ERROR_CODE | |
""" | |
lines = get_non_default_options(FLAGS.uncrustify_binary_path, | |
FLAGS.config_file_path, ) | |
config_lines_ndef = len(lines) | |
config_lines_init = count_lines(FLAGS.config_file_path) | |
if not FLAGS.empty_nochange or (config_lines_ndef != config_lines_init): | |
if not FLAGS.quiet: | |
print("%s" % '# '.ljust(78, '-')) | |
options_str = '\n'.join(lines) | |
if not options_str: | |
print(" ") | |
else: | |
print(options_str, file=stdout) | |
if not FLAGS.quiet: | |
print("%s" % '# '.ljust(78, '-')) | |
print("# initial config lines: %d,\n" | |
"# default options and unneeded lines: %d,\n" | |
% (config_lines_init, config_lines_init - config_lines_ndef)) | |
return ERROR_CODE.NONE | |
def main(): | |
""" | |
calls the mode that was specified by the -m script argument, | |
defaults to reduce_mode if not provided or unknown mode | |
accesses global var(s): MODES, FLAGS | |
:return: int | |
---------------------------------------------------------------------------- | |
return code | |
""" | |
if FLAGS.mode == MODES[1]: | |
return no_default_mode() | |
return reduce_mode() | |
def valid_file(arg_parser, *args): | |
""" | |
checks if on of the provided paths is a file | |
Parameters | |
---------------------------------------------------------------------------- | |
:param arg_parser: | |
argument parser object that is called if no file is found | |
:param args: list< str > | |
a list of file path that is going to be checked | |
:return: str | |
---------------------------------------------------------------------------- | |
path to an existing file | |
""" | |
arg = None | |
found_flag = False | |
for arg in args: | |
if exists(arg): | |
found_flag = True | |
break | |
if not found_flag: | |
arg_parser.error("file(s) do not exist: %s" % args) | |
return arg | |
if __name__ == "__main__": | |
""" | |
parses all script arguments and calls main() | |
accesses global var(s): FLAGS, ERROR_CODE, MODES | |
""" | |
arg_parser = argparse.ArgumentParser() | |
group_general = arg_parser.add_argument_group( | |
'general options', 'Options used by both modes') | |
group_general.add_argument( | |
'-q', '--quiet', | |
default=False, | |
action='store_true', | |
help='Whether or not messages, other than the actual config output, ' | |
'should be printed to stdout.' | |
) | |
group_general.add_argument( | |
'--empty-nochange', | |
default=False, | |
action='store_true', | |
help='Do not print anything to stdout if no options could be removed' | |
) | |
group_general.add_argument( | |
'-m', '--mode', | |
type=str, | |
choices=MODES, | |
default=MODES[0], | |
help="The script operation mode. Defaults to '%s'" % MODES[0] | |
) | |
group_general.add_argument( | |
'-b', '--uncrustify_binary_path', | |
metavar='<path>', | |
type=lambda x: valid_file( | |
arg_parser, x, | |
"../build/uncrustify.exe", | |
"../build/Debug/uncrustify", | |
"../build/Debug/uncrustify.exe", | |
"../build/Release/uncrustify", | |
"../build/Release/uncrustify.exe"), | |
default="../build/uncrustify", | |
help="The Uncrustify binary file path. Is searched in known locations " | |
"in the 'Uncrustify/build/' directory if no <path> is provided." | |
) | |
group_general.add_argument( | |
'-c', '--config_file_path', | |
metavar='<path>', | |
type=lambda x: valid_file(arg_parser, x), | |
required=True, | |
help='Path to the config file.' | |
) | |
group_reduce = arg_parser.add_argument_group( | |
'reduce mode', 'Options to reduce configuration file options') | |
group_reduce.add_argument( | |
'-i', '--input_file_path', | |
metavar='<path>', | |
type=lambda x: valid_file(arg_parser, x), | |
nargs='+', | |
action='append', | |
help="Path to the unformatted source file. " | |
"Required if mode '%s' is used" % MODES[0] | |
) | |
group_reduce.add_argument( | |
'-f', '--formatted_file_path', | |
metavar='<path>', | |
type=lambda x: valid_file(arg_parser, x), | |
nargs='+', | |
action='append', | |
help="Path to the formatted source file. " | |
"Required if mode '%s' is used" % MODES[0] | |
) | |
group_reduce.add_argument( | |
'-l', '--lang', | |
metavar='<str>', | |
nargs='+', | |
required=False, | |
action='append', | |
help='Uncrustify processing language for each input file' | |
) | |
group_reduce.add_argument( | |
'-j', '--jobs', | |
metavar='<nr>', | |
type=int, | |
default=cpu_count(), | |
help='Number of concurrent jobs.' | |
) | |
group_reduce.add_argument( | |
'-p', '--passes', | |
metavar='<nr>', | |
type=int, | |
default=5, | |
help='Max. number of cleaning passes.' | |
) | |
group_no_default = arg_parser.add_argument_group( | |
'no-default mode', 'Options to remove configuration file option with ' | |
'default values: ~~_Currently only the general' | |
' options are used for this mode_~~') | |
FLAGS, unparsed = arg_parser.parse_known_args() | |
if FLAGS.lang is not None: | |
FLAGS.lang = [j for i in FLAGS.lang for j in i] | |
if FLAGS.mode == MODES[0]: | |
if not FLAGS.input_file_path or not FLAGS.formatted_file_path: | |
arg_parser.error("Flags -f and -i are required in Mode '%s'!" | |
% MODES[0]) | |
sys_exit(ERROR_CODE.FLAGS) | |
# flatten 2 dimensional args: -f p -f p -f p -f p0 p1 p2 -> [[],[], ...] | |
FLAGS.input_file_path = [j for i in FLAGS.input_file_path for j in i] | |
FLAGS.formatted_file_path = [j for i in | |
FLAGS.formatted_file_path for j in i] | |
if len(FLAGS.input_file_path) != len(FLAGS.formatted_file_path): | |
print("Unequal amount of input and formatted file paths.", | |
file=stderr) | |
sys_exit(ERROR_CODE.FLAGS) | |
sys_exit(main()) |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment