From 3ff2b08d82e590b3841f94cf05c756a693cfa8a8 Mon Sep 17 00:00:00 2001 From: latercomer Date: Sun, 21 Apr 2024 01:17:18 -0400 Subject: [PATCH] =?UTF-8?q?[clang-format]=20=E5=A2=9E=E5=8A=A0clang-format?= =?UTF-8?q?=E6=A0=BC=E5=BC=8F=E5=8C=96=E9=85=8D=E7=BD=AE=EF=BC=8C=E9=80=9A?= =?UTF-8?q?=E8=BF=87ide=E6=88=96=E8=80=85=E6=89=8B=E5=8A=A8=E8=BF=90?= =?UTF-8?q?=E8=A1=8Ctools/run-clang-format.py=E8=BF=9B=E8=A1=8C=E4=BB=A3?= =?UTF-8?q?=E7=A0=81=E8=87=AA=E5=8A=A8=E6=A0=BC=E5=BC=8F=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .clang-format | 242 ++++++++++ bsp/.clang-format | 11 + .../dfs_v1/filesystems/elmfat/.clang-format | 11 + .../dfs_v2/filesystems/elmfat/.clang-format | 11 + components/net/lwip/.clang-format | 11 + tools/kconfig-frontends/.clang-format | 11 + tools/release/README.md | 42 ++ tools/release/run-clang-format.py | 426 ++++++++++++++++++ 8 files changed, 765 insertions(+) create mode 100644 .clang-format create mode 100644 bsp/.clang-format create mode 100644 components/dfs/dfs_v1/filesystems/elmfat/.clang-format create mode 100644 components/dfs/dfs_v2/filesystems/elmfat/.clang-format create mode 100644 components/net/lwip/.clang-format create mode 100644 tools/kconfig-frontends/.clang-format create mode 100644 tools/release/run-clang-format.py diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000000..c6c8a8afeb --- /dev/null +++ b/.clang-format @@ -0,0 +1,242 @@ +# Available style options are described in https://clang.llvm.org/docs/ClangFormatStyleOptions.html +# +# An easy way to create the .clang-format file is: +# +# clang-format -style=llvm -dump-config > .clang-format +# +--- +Language: Cpp +BasedOnStyle: LLVM +AccessModifierOffset: -1 +AlignAfterOpenBracket: Align +AlignArrayOfStructures: Right +AlignConsecutiveAssignments: + Enabled: true + AcrossEmptyLines: false + AcrossComments: false + AlignCompound: true + PadOperators: true +AlignConsecutiveBitFields: + Enabled: true + AcrossEmptyLines: false + AcrossComments: false + AlignCompound: true + PadOperators: true +AlignConsecutiveDeclarations: + Enabled: false + AcrossEmptyLines: false + AcrossComments: false + AlignCompound: false + PadOperators: false +AlignConsecutiveMacros: + Enabled: true + AcrossEmptyLines: false + AcrossComments: false + AlignCompound: false + PadOperators: false +AlignConsecutiveShortCaseStatements: + Enabled: false + AcrossEmptyLines: false + AcrossComments: false + AlignCaseColons: false +AlignEscapedNewlines: Left +AlignOperands: Align +AlignTrailingComments: + Kind: Always + OverEmptyLines: 1 +AllowAllArgumentsOnNextLine: false +AllowAllParametersOfDeclarationOnNextLine: false +AllowShortBlocksOnASingleLine: Always +AllowShortCaseLabelsOnASingleLine: false +AllowShortEnumsOnASingleLine: false +AllowShortFunctionsOnASingleLine: None +AllowShortIfStatementsOnASingleLine: WithoutElse +AllowShortLambdasOnASingleLine: All +AllowShortLoopsOnASingleLine: true +AlwaysBreakAfterDefinitionReturnType: None +AlwaysBreakAfterReturnType: None +AlwaysBreakBeforeMultilineStrings: false +AlwaysBreakTemplateDeclarations: MultiLine +AttributeMacros: + - __capability +BinPackArguments: true +BinPackParameters: true +BitFieldColonSpacing: Both +BraceWrapping: + AfterCaseLabel: false + AfterClass: true + AfterControlStatement: Always + AfterEnum: true + AfterExternBlock: false + AfterFunction: true + AfterNamespace: true + AfterObjCDeclaration: true + AfterStruct: true + AfterUnion: false + BeforeCatch: true + BeforeElse: true + BeforeLambdaBody: false + BeforeWhile: false + IndentBraces: false + SplitEmptyFunction: true + SplitEmptyRecord: true + SplitEmptyNamespace: true +BreakAfterAttributes: Never +BreakAfterJavaFieldAnnotations: false +BreakArrays: false +BreakBeforeBinaryOperators: NonAssignment +BreakBeforeConceptDeclarations: Always +BreakBeforeBraces: Custom +BreakBeforeInlineASMColon: OnlyMultiline +BreakBeforeTernaryOperators: true +BreakConstructorInitializers: AfterColon +BreakInheritanceList: AfterColon +BreakStringLiterals: true +ColumnLimit: 0 +CommentPragmas: "^ IWYU pragma:" +CompactNamespaces: false +ConstructorInitializerIndentWidth: 4 +ContinuationIndentWidth: 4 +Cpp11BracedListStyle: true +DerivePointerAlignment: false +DisableFormat: false +EmptyLineAfterAccessModifier: Never +EmptyLineBeforeAccessModifier: Always +ExperimentalAutoDetectBinPacking: false +FixNamespaceComments: true +ForEachMacros: + - foreach + - Q_FOREACH + - BOOST_FOREACH +IfMacros: + - KJ_IF_MAYBE +IncludeBlocks: Preserve +IncludeCategories: + - Regex: '^"(llvm|llvm-c|clang|clang-c)/' + Priority: 2 + SortPriority: 0 + CaseSensitive: false + - Regex: '^(<|"(gtest|gmock|isl|json)/)' + Priority: 3 + SortPriority: 0 + CaseSensitive: false + - Regex: ".*" + Priority: 1 + SortPriority: 0 + CaseSensitive: false +IncludeIsMainRegex: "(Test)?$" +IncludeIsMainSourceRegex: "" +IndentAccessModifiers: false +IndentCaseBlocks: false +IndentCaseLabels: false +IndentExternBlock: NoIndent +IndentGotoLabels: true +IndentPPDirectives: None +IndentRequiresClause: true +IndentWidth: 4 +IndentWrappedFunctionNames: false +InsertBraces: false +InsertNewlineAtEOF: true +InsertTrailingCommas: None +IntegerLiteralSeparator: + Binary: 0 + BinaryMinDigits: 0 + Decimal: 0 + DecimalMinDigits: 0 + Hex: 0 + HexMinDigits: 0 +JavaScriptQuotes: Leave +JavaScriptWrapImports: true +KeepEmptyLinesAtTheStartOfBlocks: false +KeepEmptyLinesAtEOF: true +LambdaBodyIndentation: Signature +LineEnding: DeriveLF +MacroBlockBegin: "" +MacroBlockEnd: "" +MaxEmptyLinesToKeep: 2 +NamespaceIndentation: None +ObjCBinPackProtocolList: Auto +ObjCBlockIndentWidth: 2 +ObjCBreakBeforeNestedBlockParam: true +ObjCSpaceAfterProperty: false +ObjCSpaceBeforeProtocolList: true +PackConstructorInitializers: BinPack +PenaltyBreakAssignment: 1000 +PenaltyBreakBeforeFirstCallParameter: 19 +PenaltyBreakComment: 300 +PenaltyBreakFirstLessLess: 120 +PenaltyBreakOpenParenthesis: 0 +PenaltyBreakString: 1000 +PenaltyBreakTemplateDeclaration: 10 +PenaltyExcessCharacter: 1000000 +PenaltyIndentedWhitespace: 0 +PenaltyReturnTypeOnItsOwnLine: 1000 +PointerAlignment: Right +PPIndentWidth: 4 +QualifierAlignment: Leave +ReferenceAlignment: Pointer +ReflowComments: false +RemoveBracesLLVM: false +RemoveParentheses: Leave +RemoveSemicolon: false +RequiresClausePosition: OwnLine +RequiresExpressionIndentation: OuterScope +SeparateDefinitionBlocks: Leave +ShortNamespaceLines: 1 +SortIncludes: Never +SortJavaStaticImport: Before +SortUsingDeclarations: LexicographicNumeric +SpaceAfterCStyleCast: false +SpaceAfterLogicalNot: false +SpaceAfterTemplateKeyword: true +SpaceAroundPointerQualifiers: Both +SpaceBeforeAssignmentOperators: true +SpaceBeforeCaseColon: false +SpaceBeforeCpp11BracedList: false +SpaceBeforeCtorInitializerColon: true +SpaceBeforeInheritanceColon: true +SpaceBeforeJsonColon: false +SpaceBeforeParens: ControlStatements +SpaceBeforeParensOptions: + AfterControlStatements: true + AfterForeachMacros: true + AfterFunctionDefinitionName: false + AfterFunctionDeclarationName: false + AfterIfMacros: true + AfterOverloadedOperator: false + AfterRequiresInClause: false + AfterRequiresInExpression: false + BeforeNonEmptyParentheses: false +SpaceBeforeRangeBasedForLoopColon: true +SpaceBeforeSquareBrackets: false +SpaceInEmptyBlock: false +SpacesBeforeTrailingComments: 1 +SpacesInAngles: Never +SpacesInContainerLiterals: true +SpacesInLineCommentPrefix: + Minimum: 1 + Maximum: -1 +SpacesInParens: Never +SpacesInParensOptions: + InCStyleCasts: false + InConditionalStatements: false + InEmptyParentheses: false + Other: false +SpacesInSquareBrackets: false +Standard: Latest +StatementAttributeLikeMacros: + - Q_EMIT +StatementMacros: + - Q_UNUSED + - QT_REQUIRE_VERSION +TabWidth: 4 +UseTab: Never +VerilogBreakBetweenInstancePorts: true +WhitespaceSensitiveMacros: + - BOOST_PP_STRINGIZE + - CF_SWIFT_NAME + - NS_SWIFT_NAME + - PP_STRINGIZE + - STRINGIZE +--- + diff --git a/bsp/.clang-format b/bsp/.clang-format new file mode 100644 index 0000000000..2a36a9c439 --- /dev/null +++ b/bsp/.clang-format @@ -0,0 +1,11 @@ +# Available style options are described in https://clang.llvm.org/docs/ClangFormatStyleOptions.html +# +# An easy way to create the .clang-format file is: +# +# clang-format -style=llvm -dump-config > .clang-format +# +--- +Language: Cpp +DisableFormat: true +--- + diff --git a/components/dfs/dfs_v1/filesystems/elmfat/.clang-format b/components/dfs/dfs_v1/filesystems/elmfat/.clang-format new file mode 100644 index 0000000000..2a36a9c439 --- /dev/null +++ b/components/dfs/dfs_v1/filesystems/elmfat/.clang-format @@ -0,0 +1,11 @@ +# Available style options are described in https://clang.llvm.org/docs/ClangFormatStyleOptions.html +# +# An easy way to create the .clang-format file is: +# +# clang-format -style=llvm -dump-config > .clang-format +# +--- +Language: Cpp +DisableFormat: true +--- + diff --git a/components/dfs/dfs_v2/filesystems/elmfat/.clang-format b/components/dfs/dfs_v2/filesystems/elmfat/.clang-format new file mode 100644 index 0000000000..2a36a9c439 --- /dev/null +++ b/components/dfs/dfs_v2/filesystems/elmfat/.clang-format @@ -0,0 +1,11 @@ +# Available style options are described in https://clang.llvm.org/docs/ClangFormatStyleOptions.html +# +# An easy way to create the .clang-format file is: +# +# clang-format -style=llvm -dump-config > .clang-format +# +--- +Language: Cpp +DisableFormat: true +--- + diff --git a/components/net/lwip/.clang-format b/components/net/lwip/.clang-format new file mode 100644 index 0000000000..2a36a9c439 --- /dev/null +++ b/components/net/lwip/.clang-format @@ -0,0 +1,11 @@ +# Available style options are described in https://clang.llvm.org/docs/ClangFormatStyleOptions.html +# +# An easy way to create the .clang-format file is: +# +# clang-format -style=llvm -dump-config > .clang-format +# +--- +Language: Cpp +DisableFormat: true +--- + diff --git a/tools/kconfig-frontends/.clang-format b/tools/kconfig-frontends/.clang-format new file mode 100644 index 0000000000..2a36a9c439 --- /dev/null +++ b/tools/kconfig-frontends/.clang-format @@ -0,0 +1,11 @@ +# Available style options are described in https://clang.llvm.org/docs/ClangFormatStyleOptions.html +# +# An easy way to create the .clang-format file is: +# +# clang-format -style=llvm -dump-config > .clang-format +# +--- +Language: Cpp +DisableFormat: true +--- + diff --git a/tools/release/README.md b/tools/release/README.md index a2f20b861c..18e5a3be2e 100644 --- a/tools/release/README.md +++ b/tools/release/README.md @@ -3,8 +3,50 @@ 在ENV环境下，并在release文件夹下执行 `python buildbot.py update` 可完成自动版本发布**前** **部分** 准备工作。 欢迎补充其他发布前自动化脚本。 目前可以自动更新和部署的内容包括： + 1. 更新所有BSP工程，包括.config文件、rtconfig文件更新，以及Keil\IAR等工程的刷新 2. STM32启动文件更新： 1. 对gcc的汇编启动文件中main替换为entry函数 2. 将启动文件heap降为0(Keil IAR) 3. 将GCC的堆大小扩展到0x400，与Keil IAR保持一致 + +## clang-format代码自动格式化 + +run-clang-format.py 根据`.clang-format`和`.clang-format-ignore`文件，使用clang-format工具对代码进行格式化。 + +如果**不希望**对某个文件夹进行格式化，那么在该文件夹下增加一个`.clang-format`，内容为： + +```yaml +--- +Language: Cpp +DisableFormat: true +--- +``` + +如果**不希望**对某个代码片段进行格式化，那么在代码中插入`// clang-format off/on`： + +```c +int formatted_code; +// clang-format off + void unformatted_code ; +// clang-format on +void formatted_code_again; +``` + +使用以下命令，将对除了bsp、elmfat、lwip和kconfig-frontends等文件夹之外的所有代码进行格式化： + +```shell +# 安装clang-format +pip install clang-format +# 切换到RTT目录 +cd $RTT_ROOT +# 执行格式化 +# -r递归子目录，-i是将格式化结果写入文件，-e是排除目录，-j是并行线程，.是当前目录 +python tools/release/run-clang-format.py -r -i -e bsp/**/* -j 10 . +``` + +如果格式化过程中提示以下错误，一般是文件中存在UTF-8编码无法识别的字符。 + +```shell +error: Command 'clang-format -i libcpu\aarch64\common\asm-fpu.h' returned non-zero exit status 1 +``` diff --git a/tools/release/run-clang-format.py b/tools/release/run-clang-format.py new file mode 100644 index 0000000000..76d13774d3 --- /dev/null +++ b/tools/release/run-clang-format.py @@ -0,0 +1,426 @@ +#!/usr/bin/env python +"""A wrapper script around clang-format, suitable for linting multiple files +and to use for continuous integration. + +This is an alternative API for the clang-format command line. +It runs over multiple files and directories in parallel. +A diff output is produced and a sensible exit code is returned. + +""" + +from __future__ import print_function, unicode_literals + +import argparse +import codecs +import difflib +import fnmatch +import io +import errno +import multiprocessing +import os +import signal +import subprocess +import sys +import traceback +import platform + +from functools import partial + +try: + from subprocess import DEVNULL # py3k +except ImportError: + DEVNULL = open(os.devnull, "wb") + + +DEFAULT_EXTENSIONS = "c,h,C,H,cpp,hpp,cc,hh,c++,h++,cxx,hxx" +DEFAULT_CLANG_FORMAT_IGNORE = ".clang-format-ignore" + + +class ExitStatus: + SUCCESS = 0 + DIFF = 1 + TROUBLE = 2 + + +def excludes_from_file(ignore_file): + excludes = [] + try: + with io.open(ignore_file, "r", encoding="utf-8") as f: + for line in f: + if line.startswith("#"): + # ignore comments + continue + pattern = line.rstrip() + if not pattern: + # allow empty lines + continue + excludes.append(pattern) + except EnvironmentError as e: + if e.errno != errno.ENOENT: + raise + return excludes + + +def list_files(files, recursive=False, extensions=None, exclude=None): + if extensions is None: + extensions = [] + if exclude is None: + exclude = [] + + out = [] + for file in files: + if recursive and os.path.isdir(file): + for dirpath, dnames, fnames in os.walk(file): + fpaths = [ + os.path.relpath(os.path.join(dirpath, fname), os.getcwd()) + for fname in fnames + ] + for pattern in exclude: + # os.walk() supports trimming down the dnames list + # by modifying it in-place, + # to avoid unnecessary directory listings. + dnames[:] = [ + x + for x in dnames + if not fnmatch.fnmatch(os.path.join(dirpath, x), pattern) + ] + fpaths = [x for x in fpaths if not fnmatch.fnmatch(x, pattern)] + + for f in fpaths: + ext = os.path.splitext(f)[1][1:] + if ext in extensions: + out.append(f) + else: + out.append(file) + return out + + +def make_diff(file, original, reformatted): + return list( + difflib.unified_diff( + original, + reformatted, + fromfile="{}\t(original)".format(file), + tofile="{}\t(reformatted)".format(file), + n=3, + ) + ) + + +class DiffError(Exception): + def __init__(self, message, errs=None): + super(DiffError, self).__init__(message) + self.errs = errs or [] + + +class UnexpectedError(Exception): + def __init__(self, message, exc=None): + super(UnexpectedError, self).__init__(message) + self.formatted_traceback = traceback.format_exc() + self.exc = exc + + +def run_clang_format_diff_wrapper(args, file): + try: + ret = run_clang_format_diff(args, file) + return ret + except DiffError: + raise + except Exception as e: + raise UnexpectedError("{}: {}: {}".format(file, e.__class__.__name__, e), e) + + +def run_clang_format_diff(args, file): + # try: + # with io.open(file, "r", encoding="utf-8") as f: + # original = f.readlines() + # except IOError as exc: + # raise DiffError(str(exc)) + + if args.in_place: + invocation = [args.clang_format_executable, "-i", file] + else: + invocation = [args.clang_format_executable, file] + + if args.style: + invocation.extend(["--style", args.style]) + + if args.dry_run: + print(" ".join(invocation)) + return [], [] + + # Use of utf-8 to decode the process output. + # + # Hopefully, this is the correct thing to do. + # + # It's done due to the following assumptions (which may be incorrect): + # - clang-format will returns the bytes read from the files as-is, + # without conversion, and it is already assumed that the files use utf-8. + # - if the diagnostics were internationalized, they would use utf-8: + # > Adding Translations to Clang + # > + # > Not possible yet! + # > Diagnostic strings should be written in UTF-8, + # > the client can translate to the relevant code page if needed. + # > Each translation completely replaces the format string + # > for the diagnostic. + # > -- http://clang.llvm.org/docs/InternalsManual.html#internals-diag-translation + # + # It's not pretty, due to Python 2 & 3 compatibility. + encoding_py3 = {} + if sys.version_info[0] >= 3: + encoding_py3["encoding"] = "utf-8" + + try: + proc = subprocess.Popen( + invocation, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + universal_newlines=True, + **encoding_py3 + ) + except OSError as exc: + raise DiffError( + "Command '{}' failed to start: {}".format( + subprocess.list2cmdline(invocation), exc + ) + ) + proc_stdout = proc.stdout + proc_stderr = proc.stderr + if sys.version_info[0] < 3: + # make the pipes compatible with Python 3, + # reading lines should output unicode + encoding = "utf-8" + proc_stdout = codecs.getreader(encoding)(proc_stdout) + proc_stderr = codecs.getreader(encoding)(proc_stderr) + # hopefully the stderr pipe won't get full and block the process + outs = list(proc_stdout.readlines()) + errs = list(proc_stderr.readlines()) + proc.wait() + if proc.returncode: + raise DiffError( + "Command '{}' returned non-zero exit status {}".format( + subprocess.list2cmdline(invocation), proc.returncode + ), + errs, + ) + if args.in_place: + return [], errs + return make_diff(file, original, outs), errs + + +def bold_red(s): + return "\x1b[1m\x1b[31m" + s + "\x1b[0m" + + +def colorize(diff_lines): + def bold(s): + return "\x1b[1m" + s + "\x1b[0m" + + def cyan(s): + return "\x1b[36m" + s + "\x1b[0m" + + def green(s): + return "\x1b[32m" + s + "\x1b[0m" + + def red(s): + return "\x1b[31m" + s + "\x1b[0m" + + for line in diff_lines: + if line[:4] in ["--- ", "+++ "]: + yield bold(line) + elif line.startswith("@@ "): + yield cyan(line) + elif line.startswith("+"): + yield green(line) + elif line.startswith("-"): + yield red(line) + else: + yield line + + +def print_diff(diff_lines, use_color): + if use_color: + diff_lines = colorize(diff_lines) + if sys.version_info[0] < 3: + sys.stdout.writelines((l.encode("utf-8") for l in diff_lines)) + else: + sys.stdout.writelines(diff_lines) + + +def print_trouble(prog, message, use_colors): + error_text = "error:" + if use_colors: + error_text = bold_red(error_text) + print("{}: {} {}".format(prog, error_text, message), file=sys.stderr) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument( + "--clang-format-executable", + metavar="EXECUTABLE", + help="path to the clang-format executable", + default="clang-format", + ) + parser.add_argument( + "--extensions", + help="comma separated list of file extensions (default: {})".format( + DEFAULT_EXTENSIONS + ), + default=DEFAULT_EXTENSIONS, + ) + parser.add_argument( + "-r", + "--recursive", + action="store_true", + help="run recursively over directories", + ) + parser.add_argument( + "-d", "--dry-run", action="store_true", help="just print the list of files" + ) + parser.add_argument( + "-i", + "--in-place", + action="store_true", + help="format file instead of printing differences", + ) + parser.add_argument("files", metavar="file", nargs="+") + parser.add_argument( + "-q", + "--quiet", + action="store_true", + help="disable output, useful for the exit code", + ) + parser.add_argument( + "-j", + metavar="N", + type=int, + default=0, + help="run N clang-format jobs in parallel" " (default number of cpus + 1)", + ) + parser.add_argument( + "--color", + default="auto", + choices=["auto", "always", "never"], + help="show colored diff (default: auto)", + ) + parser.add_argument( + "-e", + "--exclude", + metavar="PATTERN", + action="append", + default=[], + help="exclude paths matching the given glob-like pattern(s)" + " from recursive search", + ) + parser.add_argument( + "--style", + default="file", + help="formatting style to apply (LLVM, Google, Chromium, Mozilla, WebKit)", + ) + + args = parser.parse_args() + + # use default signal handling, like diff return SIGINT value on ^C + # https://bugs.python.org/issue14229#msg156446 + signal.signal(signal.SIGINT, signal.SIG_DFL) + try: + signal.SIGPIPE + except AttributeError: + # compatibility, SIGPIPE does not exist on Windows + pass + else: + signal.signal(signal.SIGPIPE, signal.SIG_DFL) + + colored_stdout = False + colored_stderr = False + if args.color == "always": + colored_stdout = True + colored_stderr = True + elif args.color == "auto": + colored_stdout = sys.stdout.isatty() + colored_stderr = sys.stderr.isatty() + + version_invocation = [args.clang_format_executable, str("--version")] + try: + subprocess.check_call(version_invocation, stdout=DEVNULL) + except subprocess.CalledProcessError as e: + print_trouble(parser.prog, str(e), use_colors=colored_stderr) + return ExitStatus.TROUBLE + except OSError as e: + print_trouble( + parser.prog, + "Command '{}' failed to start: {}".format( + subprocess.list2cmdline(version_invocation), e + ), + use_colors=colored_stderr, + ) + return ExitStatus.TROUBLE + + retcode = ExitStatus.SUCCESS + + if os.path.exists(DEFAULT_CLANG_FORMAT_IGNORE): + excludes = excludes_from_file(DEFAULT_CLANG_FORMAT_IGNORE) + else: + excludes = [] + excludes.extend(args.exclude) + + files = list_files( + args.files, + recursive=args.recursive, + exclude=excludes, + extensions=args.extensions.split(","), + ) + + if not files: + return + + njobs = args.j + if njobs == 0: + njobs = multiprocessing.cpu_count() + 1 + njobs = min(len(files), njobs) + + if njobs == 1: + # execute directly instead of in a pool, + # less overhead, simpler stacktraces + it = (run_clang_format_diff_wrapper(args, file) for file in files) + pool = None + else: + pool = multiprocessing.Pool(njobs) + it = pool.imap_unordered(partial(run_clang_format_diff_wrapper, args), files) + pool.close() + while True: + try: + outs, errs = next(it) + except StopIteration: + break + except DiffError as e: + print_trouble(parser.prog, str(e), use_colors=colored_stderr) + retcode = ExitStatus.TROUBLE + sys.stderr.writelines(e.errs) + except UnexpectedError as e: + print_trouble(parser.prog, str(e), use_colors=colored_stderr) + sys.stderr.write(e.formatted_traceback) + retcode = ExitStatus.TROUBLE + # stop at the first unexpected error, + # something could be very wrong, + # don't process all files unnecessarily + if pool: + pool.terminate() + break + else: + sys.stderr.writelines(errs) + if outs == []: + continue + if not args.quiet: + print_diff(outs, use_color=colored_stdout) + if retcode == ExitStatus.SUCCESS: + retcode = ExitStatus.DIFF + if pool: + pool.join() + return retcode + + +if __name__ == "__main__": + sys.exit(main())