def to_c(self):
    lsparams = []
    for p in self.params:
        lsparams.append(p.to_c())
    if type(self.call_expr) is nodes.Raw and self.call_expr.value == ",":
        return fmt.sep(str(self.call_expr.to_c()) + ' ', lsparams)
    return fmt.sep(' ' + str(self.call_expr.to_c()) + ' ', lsparams)

def to_fmt(self, with_from=False) -> fmt.indentable:
    txt = fmt.block("{\n", "\n}", [])
    items = fmt.sep("\n---\n", [])
    for k in sorted(self._internal.keys()):
        items.lsdata.append(fmt.sep(": ", [k, fmt.tab([self._internal[k].to_fmt(with_from)])]))
    txt.lsdata.append(fmt.tab([items]))
    return txt

 def to_tl4t(self):
     params = []
     for p in self.p:
         params.append(p.to_tl4t())
     parenth = fmt.block('(', ')', fmt.sep(', ', params))
     lsblock = fmt.sep('', [
         self.call_expr.to_tl4t(),
         parenth
     ])
     return lsblock

 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) -> 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:
     res = fmt.sep('', [])
     if self.v is None:
         res.lsdata.append('*')
     else:
         res.lsdata.append(repr(self.v))
     return res

 def to_fmt(self) -> fmt.indentable:
     res = fmt.sep('\n', [])
     res.lsdata.append("kind: %s" % self.kind)
     if self.parent is not None:
         res.lsdata.append("parent: %d" % id(self.parent))
     res.lsdata.append("node: %d" % id(self.node))
     return res

 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):
     """
     Return an Fmt representation for pretty-printing
     """
     params = ""
     txt = fmt.sep(" ", ['val'])
     name = self.show_name()
     if name != "":
         txt.lsdata.append(name)
     txt.lsdata.append('(%s)' % self.value)
     txt.lsdata.append(': ' + self.tret)
     return txt