def gen_output_fmt_1(self, fmt):
        """given a single format specifier, get_output_fmt_1() constructs and returns
        a list of tuples for matching against that specifier.
        Each element of this list is a tuple

               (gen_fmt, cvt_fmt, sz)

        where:

           gen_fmt is the Python format specifier for assembling this value into
               the string constructed for output;
           cvt_fmt is the Python format specifier for converting this value into
               a string that will be assembled into the output string; and
           sz is the width of this field.

        """

        # first, remove any surrounding space
        fmt = fmt.strip()

        # get any leading digits indicating repetition
        match = re.match("(\d+)(.+)", fmt)
        if match is None:
            reps = 1
        else:
            reps = int(match.group(1))
            fmt = match.group(2)

        if fmt[0] == "(":  # process parenthesized format list recursively
            fmt = fmt[1:-1]
            fmt_list = fmt.split(",")
            rexp = self.gen_output_fmt(fmt_list)
        else:
            if fmt[0] in "iI":  # integer
                sz = fmt[1:]
                gen_fmt = "{}"
                cvt_fmt = "{:" + str(sz) + "d}"
                rexp = [(gen_fmt, cvt_fmt, int(sz))]

            elif fmt[0] in "xX":
                gen_fmt = " "
                rexp = [(gen_fmt, None, None)]

            elif fmt[0] in "eEfFgG":  # various floating point formats
                idx0 = fmt.find(".")
                sz = fmt[1:idx0]
                suffix = fmt[idx0 + 1 :]
                # The 'E' and G formats can optionally specify the width of
                # the exponent, e.g.: 'E15.3E2'.  For now we ignore any such
                # the exponent width -- but if it's there, we need to extract
                # the sequence of digits before it.
                m = re.match("(\d+).*", suffix)
                assert m is not None, f"Improper format? '{fmt}'"
                prec = m.group(1)
                gen_fmt = "{}"
                cvt_fmt = "{:" + sz + "." + prec + fmt[0] + "}"
                rexp = [(gen_fmt, cvt_fmt, int(sz))]

            elif fmt[0] in "pP":  # scaling factor
                # For now we ignore scaling: there are lots of other things we
                # need to spend time on.  To fix later if necessary.
                rest_of_fmt = fmt[1:]
                rexp = self.gen_output_fmt_1(rest_of_fmt)

            elif fmt[0] in "'\"":  # character string
                sz = len(fmt) - 2  # -2 for the quote at either end
                gen_fmt = fmt[1:-1]
                rexp = [(gen_fmt, None, None)]

            elif fmt[0] == "/":  # newlines
                gen_fmt = "\\n" * len(fmt)
                rexp = [(gen_fmt, None, None)]

            else:
                raise For2PyError(
                    f"ERROR: Unrecognized format specifier {fmt}\n"
                )

        # replicate the regular expression by the repetition factor in the format
        rexp *= reps

        return rexp
given a single format specifier, get_output_fmt_1() constructs and returns
        a list of tuples for matching against that specifier.
        Each element of this list is a tuple

               (gen_fmt, cvt_fmt, sz)

        where:

           gen_fmt is the Python format specifier for assembling this value into
               the string constructed for output;
           cvt_fmt is the Python format specifier for converting this value into
               a string that will be assembled into the output string; and
           sz is the width of this field.