py/mpconfig: Add make show-config to parse and record overall config.

pi-anl · pi-anl · commit ec0b69e6c08f · 2022-03-23T20:29:55.000+11:00
diff --git a/py/mkrules.mk b/py/mkrules.mk
@@ -123,6 +123,11 @@ $(HEADER_BUILD)/compressed.collected: $(HEADER_BUILD)/compressed.split
 	$(ECHO) "GEN $@"
 	$(Q)$(PYTHON) $(PY_SRC)/makeqstrdefs.py cat compress _ $(HEADER_BUILD)/compress $@
 
+$(HEADER_BUILD)/mpconfig.cfg: $(SRC_QSTR) $(QSTR_GLOBAL_DEPENDENCIES) | $(QSTR_GLOBAL_REQUIREMENTS)
+	$(ECHO) "GEN $@"
+	$(Q)$(PYTHON) $(PY_SRC)/mpconfig.py pp $(CPP) output $(HEADER_BUILD)/mpconfig.cfg cflags $(QSTR_GEN_CFLAGS) sources $^
+
+
 # $(sort $(var)) removes duplicates
 #
 # The net effect of this, is it causes the objects to depend on the
@@ -221,4 +226,8 @@ print-def:
 	@$(CC) -E -Wp,-dM __empty__.c
 	@$(RM) -f __empty__.c
 
+show-config: $(HEADER_BUILD)/mpconfig.cfg
+	@echo "Build configuration recorded in: $(HEADER_BUILD)/mpconfig.cfg"
+.PHONY: show-config
+
 -include $(OBJ:.o=.P)
diff --git a/py/mpconfig.py b/py/mpconfig.py
@@ -0,0 +1,203 @@
+#!/usr/bin/env python
+
+# This tool is used to provide visibility into mpconfig
+# Currently it parses configured source files and uses the
+# pre-processor to parse and present all configured
+# MICROPY_* definitions
+
+import ast
+import io
+import json
+import os
+import operator as op
+import re
+import subprocess
+import sys
+
+
+pattern = re.compile(r"(MICROPY_[A-Z_0-9]*)", flags=re.MULTILINE)
+
+
+class Args:
+    pp = None
+    output = None
+    cflags = None
+    sources = None
+
+
+args = Args()
+
+
+class ifdef:
+    def __init__(self, val):
+        self.s = str(val)
+
+    def __str__(self):
+        return self.s
+
+
+DEFINED = ifdef(1)
+
+UNDEFINED = ifdef(0)
+
+
+def find_mpconfig_defines(c_file):
+    """Find any MICROPY_* definitions in the provided c file.
+
+    :param str c_file: path to c file to check
+    :return: List[(module_name, obj_module, enabled_define)]
+    """
+    global pattern
+
+    with io.open(c_file, encoding="utf-8") as c_file_obj:
+        return set(re.findall(pattern, c_file_obj.read()))
+
+
+def preprocess(def_c_file):
+    return subprocess.check_output(args.pp + args.cflags + [def_c_file]).decode()
+
+
+def eval_expr(expr):
+    """
+    Safely evaluate maths expressions in C define strings.
+    """
+    expr = expr.replace("||", "|").replace("&&", "&")
+    try:
+        return eval_(ast.parse(expr, mode="eval").body)
+    except (TypeError, SyntaxError):
+        return expr
+
+
+def eval_(node):
+    # supported operators
+    operators = {
+        ast.Add: op.add,
+        ast.Sub: op.sub,
+        ast.Mult: op.mul,
+        ast.Div: op.truediv,
+        ast.Pow: op.pow,
+        ast.BitXor: op.xor,
+        ast.USub: op.neg,
+        ast.BitOr: op.or_,
+        ast.GtE: op.ge,
+        ast.Gt: op.gt,
+        ast.LtE: op.le,
+        ast.Lt: op.lt,
+        ast.Eq: op.eq,
+        ast.NotEq: op.ne,
+        ast.LShift: op.lshift,
+        ast.RShift: op.rshift,
+    }
+
+    if isinstance(node, ast.Num):  # <number>
+        return node.n
+    elif isinstance(node, ast.BinOp):  # <left> <operator> <right>
+        return operators[type(node.op)](eval_(node.left), eval_(node.right))
+    elif isinstance(node, ast.UnaryOp):  # <operator> <operand> e.g., -1
+        return operators[type(node.op)](eval_(node.operand))
+    elif isinstance(node, ast.Compare):  # <operator> <operand> e.g., -1
+        ret = True
+        left = eval_(node.left)
+        for opr, right in zip(node.ops, [eval_(c) for c in node.comparators]):
+            ret &= operators[type(opr)](left, right)
+        return 1 if ret else 0
+    else:
+        raise TypeError(node)
+
+
+def parse_values(mpconfig_in):
+    mpconfig = {}
+
+    for key, value in mpconfig_in.items():
+        if isinstance(value, str):
+            if key == value:
+                # Undefined
+                mpconfig[key] = UNDEFINED
+                continue
+
+            if value == "":
+                # defined
+                mpconfig[key] = DEFINED
+                continue
+
+            def _fill_mpconfig(match):
+                return str(mpconfig_in.get(match.group(0), 0))
+
+            value = re.sub(pattern, _fill_mpconfig, value)
+
+            value = eval_expr(value)
+
+        mpconfig[key] = value
+    return mpconfig
+
+
+def main():
+    args.command = sys.argv[1]
+
+    named_args = {
+        s: []
+        for s in [
+            "pp",
+            "output",
+            "cflags",
+            "sources",
+        ]
+    }
+
+    for arg in sys.argv[1:]:
+        if arg in named_args:
+            current_tok = arg
+        else:
+            named_args[current_tok].append(arg)
+
+    if not named_args["pp"] or len(named_args["output"]) != 1:
+        print("usage: %s %s ..." % (sys.argv[0], " ... ".join(named_args)))
+        sys.exit(2)
+
+    for k, v in named_args.items():
+        setattr(args, k, v)
+
+    defines = set()
+    for c_file in args.sources:
+        defines |= find_mpconfig_defines(c_file)
+
+    os.makedirs(os.path.dirname(args.output[0]), exist_ok=True)
+    def_c_file = args.output[0] + ".c"
+
+    with open(def_c_file, "w") as cdef:
+        cdef.write("#include <py/mpconfig.h>\n\n")
+        cdef.write("#define STR(a) STR_(a)\n")
+        cdef.write("#define STR_(a...) #a\n\n")
+        cdef.write("___MPCONFIG_DEFINES___\n")
+        cdef.write("{\n")
+        cdef.write(",\n".join(('"%s": STR(%s)' % (d, d) for d in defines)))
+        cdef.write("}\n")
+
+    preproc_out = preprocess(def_c_file)
+    pp_json = preproc_out.split("___MPCONFIG_DEFINES___")[-1].strip()
+    mpconfig_json = json.loads(pp_json)
+
+    mpconfig_json_eval = None
+
+    while True:
+        # re-run eval on values to process any defines dependant on other defines
+        mpconfig_json_eval = parse_values(mpconfig_json)
+        if mpconfig_json_eval == mpconfig_json:
+            break
+        mpconfig_json = mpconfig_json_eval
+
+    with open(args.output[0], "w") as out_file:
+        for key, value in sorted(mpconfig_json.items()):
+            if value is UNDEFINED:
+                out_file.write(f"# {key} is not defined\n")
+            elif value is DEFINED:
+                out_file.write(f'{key} = ""  # is defined\n')
+            elif isinstance(value, str):
+                value = value.strip('"')
+                out_file.write(f'{key} = "{value}"\n')
+            else:
+                out_file.write(f"{key} = {value}\n")
+
+
+if __name__ == "__main__":
+    main()
