docs: 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