From 7a62910a1341b41ce47e35d5944c5ffd56378a66 Mon Sep 17 00:00:00 2001 From: Alejandro Javier Asenjo Nitti Date: Sat, 7 Oct 2023 04:38:28 -0300 Subject: [PATCH] Add formatter --- .clang-format | 23 ++++++ .clang-tidy | 9 +++ Makefile | 6 ++ src/main/3440.c | 1 - src/main/5A20.c | 18 ++--- tools/format.py | 196 ++++++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 242 insertions(+), 11 deletions(-) create mode 100644 .clang-format create mode 100644 .clang-tidy create mode 100755 tools/format.py diff --git a/.clang-format b/.clang-format new file mode 100644 index 00000000..d4450a21 --- /dev/null +++ b/.clang-format @@ -0,0 +1,23 @@ +IndentWidth: 4 +Language: Cpp +UseTab: Never +ColumnLimit: 120 +PointerAlignment: Left +BreakBeforeBraces: Attach +SpaceAfterCStyleCast: false +Cpp11BracedListStyle: false +IndentCaseLabels: true +BinPackArguments: true +BinPackParameters: true +AlignAfterOpenBracket: Align +AlignOperands: true +BreakBeforeTernaryOperators: true +BreakBeforeBinaryOperators: None +AllowShortBlocksOnASingleLine: true +AllowShortIfStatementsOnASingleLine: false +AllowShortLoopsOnASingleLine: false +AllowShortCaseLabelsOnASingleLine: false +AllowShortFunctionsOnASingleLine: false +AlignEscapedNewlines: Left +AlignTrailingComments: true +SortIncludes: false \ No newline at end of file diff --git a/.clang-tidy b/.clang-tidy new file mode 100644 index 00000000..79af26fb --- /dev/null +++ b/.clang-tidy @@ -0,0 +1,9 @@ +Checks: 'readability-*,-readability-magic-numbers,-readability-uppercase-literal-suffix,-readability-non-const-parameter,-readability-else-after-return,clang-diagnostic-*,clang-analyzer-*,-clang-analyzer-security.insecureAPI.*,-clang-analyzer-deadcode.DeadStores,-clang-analyzer-core.uninitialized.ArraySubscript,-clang-analyzer-core.UndefinedBinaryOperatorResult,bugprone*,-bugprone-macro-parentheses,-bugprone-reserved-identifier,-bugprone-narrowing-conversions,-bugprone-too-small-loop-variable,-bugprone-integer-division,-bugprone-sizeof-expression,-bugprone-suspicious-include,modernize*,-bugprone-branch-clone,-bugprone-signed-char-misuse,performance*,portability*,diagnostic-*,analyzer-*,misc*' +WarningsAsErrors: '' +HeaderFilterRegex: '^(src|include)\/.*\.h$' +FormatStyle: 'file' +CheckOptions: + # Require argument names to match exactly (instead of allowing a name to be a prefix/suffix of another) + # Note: 'true' is expected by clang-tidy 12+ but '1' is used for compatibility with older versions + - key: readability-inconsistent-declaration-parameter-name.Strict + value: 1 diff --git a/Makefile b/Makefile index efae78a6..ce0b52a3 100644 --- a/Makefile +++ b/Makefile @@ -215,6 +215,12 @@ clean: @git clean -fdx bin/ @git clean -fdx build/ +format: + @./tools/format.py + +checkformat: + @./tools/check_format.sh + #### Various Recipes #### diff --git a/src/main/3440.c b/src/main/3440.c index 56e1c537..3c6c02bf 100644 --- a/src/main/3440.c +++ b/src/main/3440.c @@ -32,5 +32,4 @@ void func_80002C50(void) { func_80020720(&D_800E2318, 14, 0); } - #pragma GLOBAL_ASM("asm/us/nonmatchings/main/3440/func_80002CB8.s") diff --git a/src/main/5A20.c b/src/main/5A20.c index a3081f84..f64c76ed 100644 --- a/src/main/5A20.c +++ b/src/main/5A20.c @@ -13,11 +13,9 @@ extern s32 D_8013B3AC; extern s32 D_8013B3B0; extern s32 D_8013B3B4; - extern void func_80005680(s32, s32); extern f32 func_8001FBE8(f32); extern u64 func_80023000(void); -extern f32 func_8001FBE8(f32); f32 func_80004E20(f32 arg0, f32 arg1) { return arg0 - ((s32)(arg0 / arg1) * arg1); @@ -54,9 +52,9 @@ f32 func_80005100(f32 arg0, f32 arg1) { if (arg1 < 0.0f) { if (arg0 < 0.0f) { - return -(D_800C80E0 - func_8001FBE8(fabs(arg0 / arg1))); + return -(D_800C80E0 - func_8001FBE8(fabsf(arg0 / arg1))); } else { - return D_800C80E4 - func_8001FBE8(fabs(arg0 / arg1)); + return D_800C80E4 - func_8001FBE8(fabsf(arg0 / arg1)); } } else { return func_8001FBE8(arg0 / arg1); @@ -69,14 +67,14 @@ f32 func_80005320(f32 arg0, f32 arg1) { if ((arg0 == 0.0f) && (arg1 == 0.0f)) { return 0.0f; } - + if (arg0 == 0.0f) { if (arg1 < 0.0f) { return D_800C80FC; } return D_800C8100; } - + if (arg1 == 0.0f) { return 0.0f; } @@ -89,7 +87,7 @@ f32 func_80005320(f32 arg0, f32 arg1) { f32 func_800055DC(f32 arg0, s32 arg1) { f32 var_fv1 = 1.0f; - + while (arg1 > 0) { arg1--; var_fv1 *= arg0; @@ -105,7 +103,7 @@ void func_80005604(s32* arg0, s32* arg1, s32 arg2, s32 arg3, s32 arg4) { return; } *arg1 = arg3; - + if (arg2 < arg4) { *arg0 = arg2; return; @@ -113,14 +111,14 @@ void func_80005604(s32* arg0, s32* arg1, s32 arg2, s32 arg3, s32 arg4) { *arg0 = arg4; return; } - + if (arg2 < arg4) { *arg0 = arg3; *arg1 = arg4; return; } *arg1 = arg2; - + if (arg3 < arg4) { *arg0 = arg3; return; diff --git a/tools/format.py b/tools/format.py new file mode 100755 index 00000000..c0aca91a --- /dev/null +++ b/tools/format.py @@ -0,0 +1,196 @@ +#!/usr/bin/env python3 + +import argparse +import glob +import multiprocessing +import os +import re +import shutil +import subprocess +import sys +import tempfile +from functools import partial +from typing import List + + +# clang-format, clang-tidy and clang-apply-replacements default version +# This specific version is used when available, for more consistency between contributors +CLANG_VER = 14 + +# Clang-Format options (see .clang-format for rules applied) +FORMAT_OPTS = "-i -style=file" + +# Clang-Tidy options (see .clang-tidy for checks enabled) +TIDY_OPTS = "-p ." +TIDY_FIX_OPTS = "--fix --fix-errors" + +# Clang-Apply-Replacements options (used for multiprocessing) +APPLY_OPTS = "" + +# Compiler options used with Clang-Tidy +# Normal warnings are disabled with -Wno-everything to focus only on tidying +INCLUDES = "-Iinclude -Isrc -Ibuild -I. -Ilib/ultralib/include -Ilib/ultralib/include/PR -Ibin/jp -Ibin/cn" +DEFINES = "-D_LANGUAGE_C -DNON_MATCHING -D_MIPS_SZLONG=32" +COMPILER_OPTS = f"-fno-builtin -std=gnu90 -m32 -Wno-everything {INCLUDES} {DEFINES}" + + +def get_clang_executable(allowed_executables: List[str]): + for executable in allowed_executables: + try: + subprocess.check_call( + [executable, "--version"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + return executable + except FileNotFoundError or subprocess.CalledProcessError: + pass + return None + + +def get_tidy_version(tidy_executable: str): + tidy_version_run = subprocess.run( + [tidy_executable, "--version"], stdout=subprocess.PIPE, universal_newlines=True) + match = re.search(r"LLVM version ([0-9]+)", tidy_version_run.stdout) + return int(match.group(1)) + + +CLANG_FORMAT = get_clang_executable([f"clang-format-{CLANG_VER}"]) +if CLANG_FORMAT is None: + sys.exit(f"Error: clang-format-{CLANG_VER} not found") + +CLANG_TIDY = get_clang_executable([f"clang-tidy-{CLANG_VER}", "clang-tidy"]) +if CLANG_TIDY is None: + sys.exit(f"Error: neither clang-tidy-{CLANG_VER} nor clang-tidy found") + +CLANG_APPLY_REPLACEMENTS = get_clang_executable( + [f"clang-apply-replacements-{CLANG_VER}", "clang-apply-replacements"]) + +# Try to detect the clang-tidy version and add --fix-notes for version 13+ +# This is used to ensure all fixes are applied properly in recent versions +if get_tidy_version(CLANG_TIDY) >= 13: + TIDY_FIX_OPTS += " --fix-notes" + + +def list_chunks(list: List, chunk_length: int): + for i in range(0, len(list), chunk_length): + yield list[i: i + chunk_length] + + +def run_clang_format(files: List[str]): + exec_str = f"{CLANG_FORMAT} {FORMAT_OPTS} {' '.join(files)}" + subprocess.run(exec_str, shell=True) + + +def run_clang_tidy(files: List[str]): + exec_str = f"{CLANG_TIDY} {TIDY_OPTS} {TIDY_FIX_OPTS} {' '.join(files)} -- {COMPILER_OPTS}" + subprocess.run(exec_str, shell=True, + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + + +def run_clang_tidy_with_export(tmp_dir: str, files: List[str]): + (handle, tmp_file) = tempfile.mkstemp(suffix=".yaml", dir=tmp_dir) + os.close(handle) + + exec_str = f"{CLANG_TIDY} {TIDY_OPTS} --export-fixes={tmp_file} {' '.join(files)} -- {COMPILER_OPTS}" + subprocess.run(exec_str, shell=True, + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + + +def run_clang_apply_replacements(tmp_dir: str): + exec_str = f"{CLANG_APPLY_REPLACEMENTS} {APPLY_OPTS} {tmp_dir}" + subprocess.run(exec_str, shell=True) + + +def add_final_new_line(file: str): + # https://backreference.org/2010/05/23/sanitizing-files-with-no-trailing-newline/index.html + # "gets the last character of the file pipes it into read, which will exit with a nonzero exit + # code if it encounters EOF before newline (so, if the last character of the file isn't a newline). + # If read exits nonzero, then append a newline onto the file using echo (if read exits 0, + # that satisfies the ||, so the echo command isn't run)." (https://stackoverflow.com/a/34865616) + exec_str = f"tail -c1 {file} | read -r _ || echo >> {file}" + subprocess.run(exec_str, shell=True) + + +def format_files(src_files: List[str], extra_files: List[str], nb_jobs: int): + if nb_jobs != 1: + print(f"Formatting files with {nb_jobs} jobs") + else: + print(f"Formatting files with a single job (consider using -j to make this faster)") + + # Format files in chunks to improve performance while still utilizing jobs + file_chunks = list(list_chunks(src_files, (len(src_files) // nb_jobs) + 1)) + + print("Running clang-format...") + # clang-format only applies changes in the given files, so it's safe to run in parallel + with multiprocessing.get_context("fork").Pool(nb_jobs) as pool: + pool.map(run_clang_format, file_chunks) + + print("Running clang-tidy...") + if nb_jobs > 1: + # clang-tidy may apply changes in #included files, so when running it in parallel we use --export-fixes + # then we call clang-apply-replacements to apply all suggested fixes at the end + tmp_dir = tempfile.mkdtemp() + + try: + with multiprocessing.get_context("fork").Pool(nb_jobs) as pool: + pool.map(partial(run_clang_tidy_with_export, tmp_dir), file_chunks) + + run_clang_apply_replacements(tmp_dir) + finally: + shutil.rmtree(tmp_dir) + else: + run_clang_tidy(src_files) + + print("Adding missing final new lines...") + # Adding final new lines is safe to do in parallel and can be applied to all types of files + with multiprocessing.get_context("fork").Pool(nb_jobs) as pool: + pool.map(add_final_new_line, src_files + extra_files) + + print("Done formatting files.") + + +def main(): + parser = argparse.ArgumentParser( + description="Format files in the codebase to enforce most style rules") + parser.add_argument("files", metavar="file", nargs="*") + parser.add_argument( + "--show-paths", + dest="show_paths", + action="store_true", + help="Print the paths to the clang-* binaries used", + ) + parser.add_argument( + "-j", + dest="jobs", + type=int, + nargs="?", + default=1, + help="number of jobs to run (default: 1 without -j, number of cpus with -j)", + ) + args = parser.parse_args() + + if args.show_paths: + import shutil + + print("CLANG_FORMAT ->", shutil.which(CLANG_FORMAT)) + print("CLANG_TIDY ->", shutil.which(CLANG_TIDY)) + print("CLANG_APPLY_REPLACEMENTS ->", + shutil.which(CLANG_APPLY_REPLACEMENTS)) + + nb_jobs = args.jobs or multiprocessing.cpu_count() + if nb_jobs > 1: + if CLANG_APPLY_REPLACEMENTS is None: + sys.exit( + f"Error: neither clang-apply-replacements-{CLANG_VER} nor clang-apply-replacements found (required to use -j)" + ) + + if args.files: + files = args.files + extra_files = [] + else: + files = glob.glob("src/**/*.c", recursive=True) + extra_files = glob.glob("assets/**/*.xml", recursive=True) + + format_files(files, extra_files, nb_jobs) + + +if __name__ == "__main__": + main()