tools/codeformat.py: Add formatter using uncrustify for C, black for Py.

This commit adds a tool, codeformat.py, which will reformat C and Python
code to fit a certain style.  By default the tool will reformat (almost)
all the original (ie not 3rd-party) .c, .h and .py files in this
repository.  Passing filenames on the command-line to codeformat.py will
reformat only those.  Reformatting is done in-place.

uncrustify is used for C reformatting, which is available for many
platforms and can be easily built from source, see
https://github.com/uncrustify/uncrustify.  The configuration for uncrustify
is also added in this commit and values are chosen to best match the
existing code style.  A small post-processing stage on .c and .h files is
done by codeformat.py (after running uncrustify) to fix up some minor
items:
- space inserted after * when used as multiplication with sizeof
- #if/ifdef/ifndef/elif/else/endif are dedented by one level when they are
  configuring if-blocks and case-blocks.

For Python code, the formatter used is black, which can be pip-installed;
see https://github.com/psf/black.  The defaults are used, except for line-
length which is set at 99 characters to match the "about 100" line-length
limit used in C code.

The formatting tools used and their configuration were chosen to strike a
balance between keeping existing style and not changing too many lines of
code, and enforcing a relatively strict style (especially for Python code).
This should help to keep the code consistent across everything, and reduce
cognitive load when writing new code to match the style.

tools/codeformat.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+#
+# This file is part of the MicroPython project, http://micropython.org/
+#
+# The MIT License (MIT)
+#
+# Copyright (c) 2020 Damien P. George
+# Copyright (c) 2020 Jim Mussared
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+import argparse
+import glob
+import itertools
+import os
+import re
+import subprocess
+
+# Relative to top-level repo dir.
+PATHS = [
+    # C
+    "extmod/*.[ch]",
+    "lib/netutils/*.[ch]",
+    "lib/timeutils/*.[ch]",
+    "lib/utils/*.[ch]",
+    "mpy-cross/*.[ch]",
+    "ports/*/*.[ch]",
+    "py/*.[ch]",
+    # Python
+    "drivers/**/*.py",
+    "examples/**/*.py",
+    "extmod/**/*.py",
+    "ports/**/*.py",
+    "py/**/*.py",
+    "tools/**/*.py",
+]
+
+EXCLUSIONS = [
+    # STM32 build includes generated Python code.
+    "ports/*/build*",
+    # gitignore in ports/unix ignores *.py, so also do it here.
+    "ports/unix/*.py",
+]
+
+# Path to repo top-level dir.
+TOP = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+
+UNCRUSTIFY_CFG = os.path.join(TOP, "tools/uncrustify.cfg")
+
+C_EXTS = (
+    ".c",
+    ".h",
+)
+PY_EXTS = (".py",)
+
+
+FIXUP_REPLACEMENTS = (
+    (re.compile("sizeof\(([a-z_]+)\) \*\(([a-z_]+)\)"), r"sizeof(\1) * (\2)"),
+    (re.compile("([0-9]+) \*sizeof"), r"\1 * sizeof"),
+)
+
+
+def list_files(paths, exclusions=None, prefix=""):
+    files = set()
+    for pattern in paths:
+        files.update(glob.glob(os.path.join(prefix, pattern), recursive=True))
+    for pattern in exclusions or []:
+        files.difference_update(glob.fnmatch.filter(files, os.path.join(prefix, pattern)))
+    return sorted(files)
+
+
+def fixup_c(filename):
+    # Read file.
+    with open(filename) as f:
+        lines = f.readlines()
+
+    # Write out file with fixups.
+    with open(filename, "w", newline="") as f:
+        dedent_stack = []
+        while lines:
+            # Get next line.
+            l = lines.pop(0)
+
+            # Dedent #'s to match indent of following line (not previous line).
+            m = re.match(r"( +)#(if |ifdef |ifndef |elif |else|endif)", l)
+            if m:
+                indent = len(m.group(1))
+                directive = m.group(2)
+                if directive in ("if ", "ifdef ", "ifndef "):
+                    l_next = lines[0]
+                    indent_next = len(re.match(r"( *)", l_next).group(1))
+                    if indent - 4 == indent_next and re.match(r" +(} else |case )", l_next):
+                        # This #-line (and all associated ones) needs dedenting by 4 spaces.
+                        l = l[4:]
+                        dedent_stack.append(indent - 4)
+                    else:
+                        # This #-line does not need dedenting.
+                        dedent_stack.append(-1)
+                else:
+                    if dedent_stack[-1] >= 0:
+                        # This associated #-line needs dedenting to match the #if.
+                        indent_diff = indent - dedent_stack[-1]
+                        assert indent_diff >= 0
+                        l = l[indent_diff:]
+                    if directive == "endif":
+                        dedent_stack.pop()
+
+            # Apply general regex-based fixups.
+            for regex, replacement in FIXUP_REPLACEMENTS:
+                l = regex.sub(replacement, l)
+
+            # Write out line.
+            f.write(l)
+
+        assert not dedent_stack, filename
+
+
+def main():
+    cmd_parser = argparse.ArgumentParser(description="Auto-format C and Python files.")
+    cmd_parser.add_argument("-c", action="store_true", help="Format C code only")
+    cmd_parser.add_argument("-p", action="store_true", help="Format Python code only")
+    cmd_parser.add_argument("files", nargs="*", help="Run on specific globs")
+    args = cmd_parser.parse_args()
+
+    # Setting only one of -c or -p disables the other. If both or neither are set, then do both.
+    format_c = args.c or not args.p
+    format_py = args.p or not args.c
+
+    # Expand the globs passed on the command line, or use the default globs above.
+    files = []
+    if args.files:
+        files = list_files(args.files)
+    else:
+        files = list_files(PATHS, EXCLUSIONS, TOP)
+
+    # Extract files matching a specific language.
+    def lang_files(exts):
+        for file in files:
+            if os.path.splitext(file)[1].lower() in exts:
+                yield file
+
+    # Run tool on N files at a time (to avoid making the command line too long).
+    def batch(cmd, files, N=200):
+        while True:
+            file_args = list(itertools.islice(files, N))
+            if not file_args:
+                break
+            subprocess.check_call(cmd + file_args)
+
+    # Format C files with uncrustify.
+    if format_c:
+        batch(["uncrustify", "-c", UNCRUSTIFY_CFG, "-lC", "--no-backup"], lang_files(C_EXTS))
+        for file in lang_files(C_EXTS):
+            fixup_c(file)
+
+    # Format Python files with black.
+    if format_py:
+        batch(["black", "-q", "--fast", "--line-length=99"], lang_files(PY_EXTS))
+
+
+if __name__ == "__main__":
+    main()