ports: Standardise arguments and output for make-pins.py script.

All ports now use `--board-csv`, `--prefix`, `--output-souce`,
`--output-header` and no longer write to stdout.  This matches the esp32
implementation.

Ports that have an AF input use `--af-csv` (to match `--board-csv`).

Any additional output files are now prefixed with `output-` (e.g.
`--output-af-const`).

Default arguments are removed (all makefiles should always specify all
arguments, using default values is likely an error).

Replaced the `af-defs-cmp-strings` and `hdr-obj-decls` args for stm32 with
just `mboot-mode`.  Previously they were set on the regular build, now the
logic is reversed so mboot sets it.

This work was funded through GitHub Sponsors.

Signed-off-by: Jim Mussared <jim.mussared@gmail.com>

ports/renesas-ra/boards/make-pins.py

@@ -28,18 +28,19 @@ class PinAD(object):
     def channel(self):
         return self._channel
 
-    def print(self):
+    def print(self, out_source):
         print(
             "const pin_ad_obj_t pin_{:s}_ad_obj = PIN_AD({:s}, {:d}, {:d}, {:d});".format(
                 self._cpu_pin_name, self._name, self._pin_idx, self._bit, self._channel
-            )
+            ),
+            file=out_source,
         )
-        print("")
+        print("", file=out_source)
 
-    def print_header(self, hdr_file):
+    def print_header(self, out_header):
         n = self.cpu_pin_name()
-        hdr_file.write("extern const pin_ad_obj_t pin_{:s}_ad_obj;\n".format(n))
-        hdr_file.write("#define pin_{:s}_ad (&pin_{:s}_ad_obj)\n".format(n, n))
+        print("extern const pin_ad_obj_t pin_{:s}_ad_obj;".format(n), file=out_header)
+        print("#define pin_{:s}_ad (&pin_{:s}_ad_obj)".format(n, n), file=out_header)
 
 
 class Pin(object):
@@ -78,22 +79,23 @@ class Pin(object):
             ad_channel = int(ad_str[2:4])
             self._pin_ad.append(PinAD(ad_str, self._name, self._pin_idx, ad_bit, ad_channel))
 
-    def print(self):
+    def print(self, out_source):
         pin_ad_name = "NULL"
         for pin_ad in self._pin_ad:
-            pin_ad.print()
+            pin_ad.print(out_source)
             pin_ad_name = "pin_{:s}_ad".format(pin_ad.cpu_pin_name())
         print(
             "const machine_pin_obj_t pin_{:s}_obj = PIN({:s}, {:d}, {:s});".format(
                 self._name, self._name, self._pin_idx, pin_ad_name
-            )
+            ),
+            file=out_source,
         )
-        print("")
+        print("", file=out_source)
 
-    def print_header(self, hdr_file):
+    def print_header(self, out_header):
         n = self.cpu_pin_name()
-        hdr_file.write("extern const machine_pin_obj_t pin_{:s}_obj;\n".format(n))
-        hdr_file.write("#define pin_{:s} (&pin_{:s}_obj)\n".format(n, n))
+        print("extern const machine_pin_obj_t pin_{:s}_obj;".format(n), file=out_header)
+        print("#define pin_{:s} (&pin_{:s}_obj)".format(n, n), file=out_header)
 
 
 class NamedPin(object):
@@ -152,9 +154,10 @@ class Pins(object):
                     pin.set_is_board_pin()
                     self.board_pins.append(NamedPin(board_pin_name, pin))
 
-    def print_named(self, label, named_pins):
+    def print_named(self, label, named_pins, out_source):
         print(
-            "STATIC const mp_rom_map_elem_t pin_{:s}_pins_locals_dict_table[] = {{".format(label)
+            "STATIC const mp_rom_map_elem_t pin_{:s}_pins_locals_dict_table[] = {{".format(label),
+            file=out_source,
         )
         for named_pin in named_pins:
             pin = named_pin.pin()
@@ -162,120 +165,93 @@ class Pins(object):
                 print(
                     "  {{ MP_ROM_QSTR(MP_QSTR_{:s}), MP_ROM_PTR(&pin_{:s}_obj) }},".format(
                         named_pin.name(), pin.cpu_pin_name()
-                    )
+                    ),
+                    file=out_source,
                 )
-        print("};")
+        print("};", file=out_source)
         print(
             "MP_DEFINE_CONST_DICT(pin_{:s}_pins_locals_dict, pin_{:s}_pins_locals_dict_table);".format(
                 label, label
-            )
+            ),
+            file=out_source,
         )
 
-    def print(self):
+    def print(self, out_source):
         for named_pin in self.cpu_pins:
             pin = named_pin.pin()
             if pin.is_board_pin():
-                pin.print()
-        self.print_named("cpu", self.cpu_pins)
-        print("")
-        self.print_named("board", self.board_pins)
+                pin.print(out_source)
+        self.print_named("cpu", self.cpu_pins, out_source)
+        print("", file=out_source)
+        self.print_named("board", self.board_pins, out_source)
 
-    def print_header(self, hdr_filename):
-        with open(hdr_filename, "wt") as hdr_file:
-            for named_pin in self.cpu_pins:
-                pin = named_pin.pin()
-                if pin.is_board_pin():
-                    pin.print_header(hdr_file)
+    def print_header(self, out_header):
+        for named_pin in self.cpu_pins:
+            pin = named_pin.pin()
+            if pin.is_board_pin():
+                pin.print_header(out_header)
+            pin_ads = pin.pin_ad()
+            for pin_ad in pin_ads:
+                pin_ad.print_header(out_header)
+        # provide #define's mapping board to cpu name
+        for named_pin in self.board_pins:
+            print(
+                "#define pyb_pin_{:s} pin_{:s}".format(
+                    named_pin.name(), named_pin.pin().cpu_pin_name()
+                ),
+                file=out_header,
+            )
+
+    def print_ad_hdr(self, out_ad_const):
+        for named_pin in self.cpu_pins:
+            pin = named_pin.pin()
+            if pin.is_board_pin():
                 pin_ads = pin.pin_ad()
                 for pin_ad in pin_ads:
-                    pin_ad.print_header(hdr_file)
-            # provide #define's mapping board to cpu name
-            for named_pin in self.board_pins:
-                hdr_file.write(
-                    "#define pyb_pin_{:s} pin_{:s}\n".format(
-                        named_pin.name(), named_pin.pin().cpu_pin_name()
+                    print(
+                        "  {{ MP_ROM_QSTR(MP_QSTR_{:s}), MP_ROM_INT(GPIO_{:s}) }}, \n".format(
+                            pin_ad.name(), pin_ad.name()
+                        ),
+                        file=out_ad_const,
                     )
-                )
-
-    def print_ad_hdr(self, ad_const_filename):
-        with open(ad_const_filename, "wt") as ad_const_file:
-            for named_pin in self.cpu_pins:
-                pin = named_pin.pin()
-                if pin.is_board_pin():
-                    pin_ads = pin.pin_ad()
-                    for pin_ad in pin_ads:
-                        ad_const_file.write(
-                            "  {{ MP_ROM_QSTR(MP_QSTR_{:s}), MP_ROM_INT(GPIO_{:s}) }}, \n".format(
-                                pin_ad.name(), pin_ad.name()
-                            )
-                        )
 
 
 def main():
-    parser = argparse.ArgumentParser(
-        prog="make-pins.py",
-        usage="%(prog)s [options] [command]",
-        description="Generate board specific pin file",
-    )
-    parser.add_argument(
-        "-a",
-        "--af",
-        dest="af_filename",
-        help="Specifies the alternate function file for the chip",
-        default="ra4m1_af.csv",
-    )
-    parser.add_argument(
-        "-b", "--board", dest="board_filename", help="Specifies the board file", default="pins.csv"
-    )
-    parser.add_argument(
-        "-p",
-        "--prefix",
-        dest="prefix_filename",
-        help="Specifies beginning portion of generated pins file",
-        default="ra4m1_prefix.c",
-    )
-    parser.add_argument(
-        "--ad-const",
-        dest="ad_const_filename",
-        help="Specifies header file for AD function constants.",
-        default="build/pins_ad_const.h",
-    )
-    parser.add_argument(
-        "--af-defs",
-        dest="af_defs_filename",
-        help="Specifies the filename for the alternate function defines.",
-        default="build/pins_af_defs.h",
-    )
-    parser.add_argument(
-        "-r",
-        "--hdr",
-        dest="hdr_filename",
-        help="Specifies name of generated pin header file",
-        default="build/pins.h",
-    )
-    args = parser.parse_args(sys.argv[1:])
+    parser = argparse.ArgumentParser(description="Generate board specific pin file")
+    parser.add_argument("--board-csv")
+    parser.add_argument("--af-csv")
+    parser.add_argument("--prefix")
+    parser.add_argument("--output-source")
+    parser.add_argument("--output-header")
+    parser.add_argument("--output-ad-const")
+    args = parser.parse_args()
 
     pins = Pins()
 
-    print("// This file was automatically generated by make-pins.py")
-    print("//")
-    if args.af_filename:
-        print("// --af {:s}".format(args.af_filename))
-        pins.parse_af_file(args.af_filename)
+    with open(args.output_source, "w") as out_source:
+        print("// This file was automatically generated by make-pins.py", file=out_source)
+        print("//", file=out_source)
+        if args.af_csv:
+            print("// --af {:s}".format(args.af_csv), file=out_source)
+            pins.parse_af_file(args.af_csv)
 
-    if args.board_filename:
-        print("// --board {:s}".format(args.board_filename))
-        pins.parse_board_file(args.board_filename)
+        if args.board_csv:
+            print("// --board {:s}".format(args.board_csv), file=out_source)
+            pins.parse_board_file(args.board_csv)
 
-    if args.prefix_filename:
-        print("// --prefix {:s}".format(args.prefix_filename))
-        print("")
-        with open(args.prefix_filename, "r") as prefix_file:
-            print(prefix_file.read())
+        if args.prefix:
+            print("// --prefix {:s}".format(args.prefix), file=out_source)
+            print("", file=out_source)
+            with open(args.prefix, "r") as prefix_file:
+                print(prefix_file.read(), file=out_source)
 
-    pins.print()
-    pins.print_header(args.hdr_filename)
-    pins.print_ad_hdr(args.ad_const_filename)
+        pins.print(out_source)
+
+    with open(args.output_header, "w") as out_header:
+        pins.print_header(out_header)
+
+    with open(args.output_ad_const, "w") as out_ad_const:
+        pins.print_ad_hdr(out_ad_const)
 
 
 if __name__ == "__main__":