def to_fmt(self):
    """
    Return an Fmt representation for pretty-printing
    """
    qual = "evalctx"
    lseval = []
    block = fmt.block(":\n", "", fmt.tab(lseval))
    txt = fmt.sep(" ", [qual, block])
    lseval.append(self._sig.to_fmt())
    if len(self.resolution) > 0:
        lsb = []
        for k in sorted(self.resolution.keys()):
            s = self.resolution[k]
            if s is not None:
                lsb.append(fmt.end("\n", ["'%s': %s (%s)" % (k, s, s().show_name())]))
            else:
                lsb.append(fmt.end("\n", ["'%s': Unresolved" % (k)]))
        if self._translate_to is not None:
            lsb.append("use translator:")
            lsb.append(self._translate_to.to_fmt())
        if self._variadic_types is not None:
            lsb.append("variadic types:\n")
            arity = self._sig.arity
            for t in self._variadic_types:
                lsb.append("[%d] : %s\n" % (arity, t))
                arity += 1
        lseval.append(fmt.block("\nresolution :\n", "", fmt.tab(lsb)))
    return txt

 def to_fmt(self) -> fmt.indentable:
     key = '*'
     if self.key is not None:
         key = repr(self.key)
     res = fmt.block('{' + key + ': ', '}', [])
     res.lsdata.append(self.v.to_fmt())
     return res

def to_c(self):
    return fmt.sep(
        "",
        [
            self.call_expr.to_c(),  # expr
            fmt.block('[', ']', [self.params[0].to_c()])  # index
        ]
    )

 def to_tl4t(self) -> fmt.indentable:
     lssub = []
     for s in self.body:
         lssub.append(s.to_tl4t())
     lsblock = None
     if self.root:
         lsblock = fmt.sep('', lssub)
     else:
         lsblock = fmt.block('{\n', '}', [fmt.tab(lssub)])
     return lsblock

 def to_fmt(self) -> fmt.indentable:
     res = fmt.sep('', [])
     if self.t is not object:
         res.lsdata.append(self.t.__name__)
     else:
         res.lsdata.append('*')
     iparen = []
     if self.attrs is not None:
         # TODO: render unknown attr (.?) at the end after ..., also unknown attr implie 'unstrict' mode
         iparen = fmt.sep(', ', [])
         for a in self.attrs:
             iparen.lsdata.append(a.to_fmt())
     if not self.strict:
         iparen.lsdata.append('...')
     if self.iskindof:
         paren = fmt.block('^(', ')', iparen)
     else:
         paren = fmt.block('(', ')', iparen)
     res.lsdata.append(paren)
     return res

 def to_fmt(self) -> fmt.indentable:
     res = None
     showlist = {
         'attr': {
             "res": fmt.sep('', ['.']),
             "inblock": fmt.sep('=', [self.value])
         },
         'indice': {
             "res": fmt.block('[', ']', []),
             "inblock": fmt.sep(': ', [repr(self.value)])
         },
         'key': {
             "res": fmt.block('{', '}', []),
             "inblock": fmt.sep(': ', [repr(self.value)])
         }
         }
     for k in sorted(showlist.keys()):
         v = showlist[k]
         if self.kind == CaptureContext.kind_of_node[k]:
             res = v["res"]
             inblock = v["inblock"]
             if self.node is not None:
                 if hasattr(self.node, 'to_fmt'):
                     inblock.lsdata.append(self.node.to_fmt())
                 elif type(self.node) is weakref.ReferenceType:
                     inblock.lsdata.append(repr(self.get()))
             res.lsdata.append(inblock)
     ######
     if self.kind == CaptureContext.kind_of_node['node']:
         res = fmt.sep('', [self.value])
         elmts = fmt.sep(',\n', [])
         for sk in sorted(CaptureContext.map_intern.values()):
             subelmt = None
             if hasattr(self, sk):
                 subelmt = getattr(self, sk)
             if subelmt is not None:
                 for sube in subelmt:
                     elmts.lsdata.append(sube.to_fmt())
         se = fmt.tab(fmt.block('(\n', '\n)', elmts))
         res.lsdata.append(se)
     return res

 def to_fmt(self) -> fmt.indentable:
     """
     Return an Fmt representation for pretty-printing
     """
     lsb = []
     if len(self._lsig) > 0:
         for s in self._lsig:
             lsb.append(s.to_fmt())
     block = fmt.block("(", ")", fmt.sep(', ', lsb))
     qual = "tuple"
     txt = fmt.sep("", [qual, block])
     return txt

 def to_fmt(self) -> fmt.indentable:
     txt = fmt.sep("", [self.name])
     if len(self.attributes) > 0:
         lsattr = fmt.sep(", ", [])
         lkey = sorted(self.attributes.keys())
         for k in lkey:
             t = k
             if self.attributes[k] is not None:
                 t += '=' + str(self.attributes[k])
             lsattr.lsdata.append(t)
         txt.lsdata.append(fmt.block("[", "]", lsattr))
     return txt

 def to_fmt(self) -> str:
     """
     Provide a useful representation of the register.
     """
     infos = fmt.end(";\n", [])
     s = fmt.sep(', ', [])
     for ids in sorted(self.states.keys()):
         s.lsdata.append(str(ids))
     infos.lsdata.append(fmt.block('(', ')', [s]))
     infos.lsdata.append("events:" + repr(self.events))
     infos.lsdata.append("named_events:" + repr(list(self.named_events.keys())))
     infos.lsdata.append("uid_events:" + repr(list(self.uid_events.keys())))
     return infos

def to_yml_item(item, pp, name):
    global scalar
    refcount = weakref.getweakrefcount(item)
    if refcount > 0:
        name += " &" + str(id(item))
    if type(item).__name__ in scalar:
        tag = fmt.end(
            '\n',
            fmt.sep(
                "",
                [
                    name,
                    " ",
                    yml_attr(
                        type(item).__name__,
                        repr(item)
                    )
                ]
            )
        )
        pp.append(tag)
        return
    if isinstance(item, weakref.ref):
        name += " *" + str(id(item()))
        tag = fmt.end('\n', fmt.sep("", [name, " ", repr(item)]))
        pp.append(tag)
        return
    if isinstance(item, bytes) or isinstance(item, bytearray):
        inner = fmt.tab([])
        tag = fmt.block(name + " " + str(yml_attr('type', 'bytes')) + ':\n',
                        '----' + name + '----\n', inner)
        inner.lsdata.append(fmt.sep(" ", []))
        bindata = inner.lsdata[-1].lsdata
        i = 0
        for b in item:
            bindata.append("%02X" % b)
            i += 1
            if i > 16:
                bindata.append("\n")
                i = 0
        bindata.append("\n")
        pp.append(tag)
        return
    if isinstance(item, object) and hasattr(item, '__dict__'):
        inner = fmt.tab([])
        tag = fmt.block(name + " " +
                        str(yml_attr('type', item.__class__.__name__))
                        + ':\n',
                        '', inner)
        for attr in sorted(vars(item)):
            to_yml_item(getattr(item, attr), inner.lsdata, attr)
        if len(vars(item)) == 0:
            inner.lsdata.append("\n")
        pp.append(tag)
        return
    if isinstance(item, list):
        inner = fmt.tab([])
        tag = fmt.block(
            name + " " + str(yml_attr('type', 'list')) + ':\n',
            '',
            inner
        )
        i = 0
        for subitem in item:
            idxname = str(fmt.sep(" ", ['[', i, ']']))
            to_yml_item(subitem, inner.lsdata, idxname)
            i += 1
        if len(item) == 0:
            inner.lsdata.append("\n")
        pp.append(tag)
        return
    if isinstance(item, tuple):
        inner = fmt.tab([])
        tag = fmt.block(name + " " + str(yml_attr('type', 'tuple')) + ':\n',
                        '', inner)
        i = 0
        for subitem in item:
            idxname = str(fmt.sep(" ", ["[", i, "]"]))
            to_yml_item(subitem, inner.lsdata, idxname)
            i += 1
        if len(item) == 0:
            inner.lsdata.append("\n")
        pp.append(tag)
        return
    if isinstance(item, dict):
        inner = fmt.tab([])
        tag = fmt.block(name + " " + str(yml_attr('type', 'dict')) + ':\n',
                        '', inner)
        for k in sorted(item.keys()):
            idxname = str(fmt.sep(" ", ["[", repr(k), "]"]))
            to_yml_item(item[k], inner.lsdata, idxname)
        if len(item.keys()) == 0:
            inner.lsdata.append("\n")
        pp.append(tag)
        return
    if isinstance(item, set):
        inner = fmt.tab([])
        tag = fmt.block(name + " " + str(yml_attr('type', 'set')) + ':\n',
                        '', inner)
        for subitem in sorted(item):
#.........这里部分代码省略.........

def ctype_to_c(self, func_var_name=""):
    # our global declarator
    declarator = fmt.sep("", [])
    # typename or full decl
    if func_var_name != "":
        declarator.lsdata.append(func_var_name)
    # intern prototype
    if hasattr(self, 'params'):
        # param list
        pf = fmt.sep(", ", [])
        for p in self.params:
            if p.ctype is not None:
                if isinstance(p.ctype, nodes.CType):
                    pf.lsdata.append(p.ctype.ctype_to_c(p._name))
        if hasattr(self, '_ellipsis'):
            pf.lsdata.append('...')
        if len(pf.lsdata) > 0:
            declarator.lsdata.append(fmt.block('(', ')',  pf))
        else:
            declarator.lsdata.append('()')
    # for externalize the last qualifier
    qualextern = None
    # final output
    decl_ls = fmt.sep(" ", [])
    if self.link() is not None:
        # add all qualifiers
        if len(declarator.lsdata) > 0:
            qual_list = declarator
        else:
            qual_list = fmt.sep(" ", [])
        unqual_list = self.link()
        # qualification of declaration
        while unqual_list is not None:
            if isinstance(unqual_list, nodes.ParenType):
                # surround previous defs by ()
                qual_list = fmt.sep("", [fmt.block("(", ")", [qual_list])])
                # () provide param for function pointers
                if len(unqual_list.params) > 0:
                    pf = fmt.sep(", ", [])
                    for p in unqual_list.params:
                        pf.lsdata.append(p.ctype.ctype_to_c(p._name))
                    if hasattr(unqual_list, '_ellipsis'):
                        pf.lsdata.append('...')
                    qual_list.lsdata.append(fmt.block('(', ')', pf))
            if isinstance(unqual_list, nodes.PointerType):
                qual_list.lsdata.insert(0, "*")
            if isinstance(unqual_list, nodes.AttrType):
                qual_list.lsdata.insert(0, unqual_list._attr + " ")
            if isinstance(unqual_list, nodes.QualType):
                if unqual_list._qualifier != nodes.Qualifiers.AUTO:
                    if unqual_list.link() is None:
                        qualextern = unqual_list
                    else:
                        qual_list.lsdata.insert(
                            0,
                            nodes.Qualifiers.rmap[
                                unqual_list._qualifier
                            ].lower() + " "
                        )
            if isinstance(unqual_list, nodes.ArrayType):
                # collect all consecutive array
                consec_ary = []
                consec_ary.append(unqual_list)
                unqual_list = unqual_list.link()
                while ((unqual_list is not None
                        and isinstance(unqual_list, nodes.ArrayType))):
                    consec_ary.append(unqual_list)
                    unqual_list = unqual_list.link()
                reordered = []
                for ary in consec_ary:
                    if ary.expr is not None:
                        ary_expr = None
                        if hasattr(ary.expr, 'to_c'):
                            ary_expr = ary.expr.to_c()
                        reordered.insert(0, fmt.block("[", "]", [ary_expr]))
                    else:
                        reordered.insert(0, "[]")
                qual_list.lsdata.extend(reordered)
                # rewind one for last sentence
                unqual_list = consec_ary[-1]
            unqual_list = unqual_list.link()
        # add qualified declarator
        decl_ls.lsdata.append(qual_list)
    elif len(declarator.lsdata) > 0:
        # no qualifiers just the name
        decl_ls.lsdata.append(declarator)
    # for enum
    if hasattr(self, 'enums'):
        enums = fmt.sep(",\n", [])
        for enum in self.enums:
            if enum.expr is not None and hasattr(enum.expr, 'to_c'):
                enums.lsdata.append(
                    fmt.sep(
                        " = ",
                        [enum.ident, enum.expr.to_c()]
                    ))
            else:
                enums.lsdata.append(enum.ident)
        decl_ls.lsdata.insert(0, fmt.tab(fmt.block("{\n", "}", enums)))
    # for struct
#.........这里部分代码省略.........