Exemple #1
0
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
Exemple #2
0
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
Exemple #3
0
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
Exemple #4
0
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
Exemple #5
0
def to_c(self):
    thenbody = ';\n'
    if self.thencond is not None and hasattr(self.thencond, 'to_c'):
        thenbody = fmt.tab(self.thencond.to_c())
    lsif = [
        fmt.sep(" ", ["if", fmt.block('(', ')\n', [self.condition.to_c()])]),
        thenbody
    ]
    if self.elsecond is not None and hasattr(self.elsecond, 'to_c'):
        lsif.append("else\n")
        lsif.append(fmt.tab(self.elsecond.to_c()))
    return fmt.end("", lsif)
Exemple #6
0
def to_c(self):
    thenbody = ';\n'
    if self.thencond is not None and hasattr(self.thencond, 'to_c'):
        thenbody = fmt.tab(self.thencond.to_c())
    lsif = [
        fmt.sep(" ",
                ["if", fmt.block('(', ')\n', [self.condition.to_c()])]),
        thenbody
    ]
    if self.elsecond is not None and hasattr(self.elsecond, 'to_c'):
        lsif.append("else\n")
        lsif.append(fmt.tab(self.elsecond.to_c()))
    return fmt.end("", lsif)
Exemple #7
0
def to_c(self):
    lsbody = []
    i = 0
    for it in self.body:
        subbody = it.to_c()
        if hasattr(it, 'designation'):
            subbody = fmt.sep("", [it.designation, subbody])
        if isinstance(subbody, fmt.block):
            lsbody.append(fmt.tab(["\n", subbody]))
        else:
            lsbody.append(subbody)
        i += 1
        if i > 8:
            lsbody[-1] = "\n" + str(lsbody[-1])
            i = 0
    return fmt.block("{ ", " }", fmt.tab(fmt.sep(', ', lsbody)))
Exemple #8
0
def to_cython(self, genstate) -> fmt.indentable:
    alts = fmt.tab([])
    genstate.newScopeError()
    alts.lsdata.append(tpl_althead.substitute(
        lvlid=genstate.lvlid,
        outid=genstate.outid
    ))
    for s in self.ptlist:
        if not isinstance(s, functors.Seq):
            s = functors.Seq(s)
        genstate.newScopeAlt()
        content = tpl_alt.substitute(
            code=s.to_cython(genstate),
            lvlid=genstate.lvlid,
            outid=genstate.outid,
            errid=genstate.errid,
            outerrid=genstate.outerrid
        )
        alts.lsdata.append(content)
        genstate.popScopeAlt()
    alts.lsdata.append(tpl_altfoot.substitute(
        lvlid=genstate.lvlid,
        outid=genstate.outid,
        errid=genstate.errid,
        outerrid=genstate.outerrid
    ))
    genstate.popScopeError()
    return alts
Exemple #9
0
def to_c(self):
    lsbody = []
    i = 0
    for it in self.body:
        subbody = it.to_c()
        if hasattr(it, 'designation'):
            subbody = fmt.sep("", [it.designation, subbody])
        if isinstance(subbody, fmt.block):
            lsbody.append(fmt.tab(["\n", subbody]))
        else:
            lsbody.append(subbody)
        i += 1
        if i > 8:
            lsbody[-1] = "\n" + str(lsbody[-1])
            i = 0
    return fmt.block("{ ", " }", fmt.tab(fmt.sep(', ', lsbody)))
Exemple #10
0
def to_c(self):
    if self.already_imported:
        return fmt.sep("", [])
    lsbody = []
    lsbody.append(self.ifndef.to_c())
    lsbody.append(self.define.to_c())
    lsbody.append(self.body.to_c())
    lsbody.append(self.endif.to_c())
    return fmt.end("\n\n", fmt.tab(fmt.sep("\n", lsbody)))
Exemple #11
0
 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
Exemple #12
0
 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
Exemple #13
0
def to_c(self):
    body = ';\n'
    if self.body is not None and hasattr(self.body, 'to_c'):
        body = fmt.tab(self.body.to_c())
    lswh = [
        fmt.sep(" ",
                ["switch",
                 fmt.block('(', ')\n', [self.condition.to_c()])]), body
    ]
    return fmt.sep("", lswh)
Exemple #14
0
def to_c(self):
    body = ';\n'
    if self.body is not None and hasattr(self.body, 'to_c'):
        body = fmt.tab(self.body.to_c())
    lsdo = [
        fmt.sep("\n", ["do", body]),
        fmt.sep(
            " ",
            ["while", fmt.block('(', ');\n', [self.condition.to_c()])])
    ]
    return fmt.sep("", lsdo)
Exemple #15
0
def to_yml(self):
    """
    Allow to get the YML string representation of a Node.::

        from pyrser.passes import to_yml
        
        t = Node()
        ...
        print(str(t.to_yml()))
    """
    pp = fmt.tab([])
    to_yml_item(self, pp.lsdata, "")
    return str(pp)
Exemple #16
0
def to_yml(self):
    """
    Allow to get the YML string representation of a Node.::

        from pyrser.passes import to_yml
        
        t = Node()
        ...
        print(str(t.to_yml()))
    """
    pp = fmt.tab([])
    to_yml_item(self, pp.lsdata, "")
    return str(pp)
Exemple #17
0
def to_cython(self, genstate) -> fmt.indentable:
    repn = self.pt
    if not isinstance(repn, functors.Seq):
        repn = functors.Seq(repn)
    genstate.newScopeError()
    source = fmt.tab([repn.to_cython(genstate)])
    res = tpl_repopt.substitute(
        code=self.pt.to_cython(genstate),
        lvlid=genstate.lvlid,
        outid=genstate.outid,
        errid=genstate.errid,
    )
    genstate.popScopeError()
    return res
Exemple #18
0
def to_c(self):
    body = ';\n'
    if self.body is not None and hasattr(self.body, 'to_c'):
        body = fmt.tab(self.body.to_c())
    lswh = [
        fmt.sep(
            " ",
            [
                "while",
                fmt.block('(', ')\n', [self.condition.to_c()])
            ]),
        body
    ]
    return fmt.sep("", lswh)
Exemple #19
0
def to_fmt(self) -> fmt.indentable:
    """
    Return an Fmt representation for pretty-printing
    """
    qual = "type"
    txt = fmt.sep(" ", [qual])
    txt.lsdata.append(self.show_name())
    if hasattr(self, '_hsig') and len(self._hsig) > 0:
        lsb = []
        for k in sorted(self._hsig.keys()):
            s = self._hsig[k]
            lsb.append(fmt.end("\n", [s.to_fmt()]))
        block = fmt.block(":\n", "", fmt.tab(lsb))
        txt.lsdata.append(block)
    return txt
Exemple #20
0
def to_cython(self, genstate) -> fmt.indentable:
    rule = self.pt
    if not isinstance(rule, functors.Seq):
        rule = functors.Seq(rule)
    genstate.newScopeError()
    source = fmt.tab([rule.to_cython(genstate)])
    res = tpl_lookahead.substitute(
        code=self.pt.to_cython(genstate),
        lvlid=genstate.lvlid,
        outid=genstate.outid,
        errid=genstate.errid,
        outerrid=genstate.outerrid
    )
    genstate.popScopeError()
    return res
Exemple #21
0
def to_fmt(self) -> fmt.indentable:
    """
    Return an Fmt representation for pretty-printing
    """
    qual = "type"
    txt = fmt.sep(" ", [qual])
    txt.lsdata.append(self.show_name())
    if hasattr(self, "_hsig") and len(self._hsig) > 0:
        lsb = []
        for k in sorted(self._hsig.keys()):
            s = self._hsig[k]
            lsb.append(fmt.end("\n", [s.to_fmt()]))
        block = fmt.block(":\n", "", fmt.tab(lsb))
        txt.lsdata.append(block)
    return txt
Exemple #22
0
def to_cython(self, genstate) -> fmt.indentable:
    seqs = fmt.tab([])
    genstate.newScopeError()
    seqs.lsdata.append(tpl_seqhead.substitute(
        lvlid=genstate.lvlid,
        outid=genstate.outid
    ))
    for s in self.ptlist:
        content = tpl_seq.substitute(code=s.to_cython(genstate))
        seqs.lsdata.append(content)
    seqs.lsdata.append(tpl_seqfoot.substitute(
        lvlid=genstate.lvlid,
        outid=genstate.outid,
        errid=genstate.errid,
        outerrid=genstate.outerrid
    ))
    genstate.popScopeError()
    return seqs
Exemple #23
0
def to_fmt(self) -> fmt.indentable:
    """
    Return an Fmt representation for pretty-printing
    """
    qual = "scope"
    txt = fmt.sep(" ", [qual])
    name = self.show_name()
    if name != "":
        txt.lsdata.append(name)
    if len(self._hsig) > 0 or len(self.mapTypeTranslate) > 0:
        lsb = []
        if len(self.mapTypeTranslate) > 0:
            lsb.append("translate:\n")
            lsb.append(fmt.end("\n", self.mapTypeTranslate.to_fmt()))
        for k in sorted(self._hsig.keys()):
            s = self._hsig[k]
            lsb.append(fmt.end("\n", [s.to_fmt()]))
        block = fmt.block(":\n", "", fmt.tab(lsb))
        txt.lsdata.append(block)
    return txt
Exemple #24
0
def to_fmt(self) -> fmt.indentable:
    """
    Return an Fmt representation for pretty-printing
    """
    qual = "scope"
    txt = fmt.sep(" ", [qual])
    name = self.show_name()
    if name != "":
        txt.lsdata.append(name)
    if len(self._hsig) > 0 or len(self.mapTypeTranslate) > 0:
        lsb = []
        if len(self.mapTypeTranslate) > 0:
            lsb.append("translate:\n")
            lsb.append(fmt.end("\n", self.mapTypeTranslate.to_fmt()))
        for k in sorted(self._hsig.keys()):
            s = self._hsig[k]
            lsb.append(fmt.end("\n", [s.to_fmt()]))
        block = fmt.block(":\n", "", fmt.tab(lsb))
        txt.lsdata.append(block)
    return txt
Exemple #25
0
 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
Exemple #26
0
 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
Exemple #27
0
def to_c(self):
    init_body = None
    if type(self.init) is nodes.Decl:
        init_body = decl_to_c(self.init)
    elif self.init is not None and hasattr(self.init, 'expr'):
        init_body = self.init.expr.to_c()
    cond_body = None
    if self.condition is not None and hasattr(self.condition, 'expr'):
        cond_body = self.condition.expr.to_c()
    inc_body = None
    if self.increment is not None and hasattr(self.increment, 'to_c'):
        inc_body = self.increment.to_c()
    lsfor = [
        fmt.sep(" ", [
            "for",
            fmt.block('(', ')\n',
                      [fmt.sep("; ", [init_body, cond_body, inc_body])])
        ]),
        fmt.tab(self.body.to_c())
    ]
    return fmt.end("", lsfor)
Exemple #28
0
def to_c(self):
    init_body = None
    if type(self.init) is nodes.Decl:
        init_body = decl_to_c(self.init)
    elif self.init is not None and hasattr(self.init, 'expr'):
        init_body = self.init.expr.to_c()
    cond_body = None
    if self.condition is not None and hasattr(self.condition, 'expr'):
        cond_body = self.condition.expr.to_c()
    inc_body = None
    if self.increment is not None and hasattr(self.increment, 'to_c'):
        inc_body = self.increment.to_c()
    lsfor = [
        fmt.sep(
            " ",
            [
                "for",
                fmt.block(
                    '(',
                    ')\n',
                    [
                        fmt.sep(
                            "; ",
                            [
                                init_body,
                                cond_body,
                                inc_body
                            ]
                        )
                    ]
                )
            ]
        ),
        fmt.tab(self.body.to_c())
    ]
    return fmt.end("", lsfor)
Exemple #29
0
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
    if hasattr(self, 'fields'):
        fields = []
        for field in self.fields:
            fields.append(field.to_c())
        decl_ls.lsdata.insert(0, fmt.tab(fmt.block("{\n", "}", fields)))
    # just the type name
    if hasattr(self, 'identifier'):
        decl_ls.lsdata.insert(0, self.identifier)
    # attributes composed
    if hasattr(self, '_attr_composed'):
        decl_ls.lsdata.insert(0, fmt.sep(" ", self._attr_composed))
    # specifier
    if self._specifier != nodes.Specifiers.AUTO:
        if self._specifier == nodes.Specifiers.LONGLONG:
            decl_ls.lsdata.insert(0, "long long")
        else:
            decl_ls.lsdata.insert(
                0, nodes.Specifiers.rmap[self._specifier].lower())
    # sign
    if hasattr(self, '_sign') and self._sign != nodes.Signs.AUTO:
        decl_ls.lsdata.insert(0, nodes.Signs.rmap[self._sign].lower())
    # qualifier externalized
    if qualextern is not None:
        decl_ls.lsdata.insert(
            0, nodes.Qualifiers.rmap[qualextern._qualifier].lower())
    # End by storage
    if self._storage != nodes.Storages.AUTO:
        decl_ls.lsdata.insert(0, nodes.Storages.rmap[self._storage].lower())
    return decl_ls
Exemple #30
0
 def test_00(self):
     """Test pprint functions"""
     data = fmt.end(";", ["tot"])
     self.assertEqual(str(data), "tot;", "Failed to format end")
     data = fmt.tab(fmt.end(";\n", ["tot"]))
     self.assertEqual(str(data), "    tot;\n", "Failed to format end")
     data = fmt.tab([fmt.end(";\n", ["tot"])])
     self.assertEqual(str(data), "    tot;\n", "Failed to format end")
     data = fmt.end(";", ["", fmt.tab(["\ntot", "\nplop"])])
     self.assertEqual(str(data), ";\n{tab}tot\n{tab}plop;".format(tab=" " * 4), "Failed to format end")
     data = fmt.end(";", ["", fmt.tab(["\ntot", "\nplop"])])
     self.assertEqual(str(data), ";\n{tab}tot\n{tab}plop;".format(tab=" " * 4), "Failed to format end")
     data = fmt.sep(",", ["a", "b", "c"])
     self.assertEqual(str(data), "a,b,c", "Failed to format sep")
     data = fmt.tab(fmt.sep(",\n", ["tot", "tit", "tut"]))
     self.assertEqual(str(data), "{tab}tot,\n{tab}tit,\n{tab}tut".format(tab=" " * 4), "Failed to format end")
     data = fmt.sep(",\n", [fmt.tab(["tot", "tit"]), "tut"])
     self.assertEqual(str(data), "tottit,\ntut", "Failed to format end")
     data = fmt.block("{", "}", ["a", "b", "c"])
     self.assertEqual(str(data), "{abc}", "Failed to format block")
     data = fmt.block("{", "}", [fmt.sep(",", ["a", "b", "c"])])
     self.assertEqual(str(data), "{a,b,c}", "Failed to format block/sep")
     data = fmt.sep(",", [fmt.block("{", "}", ["a", "b"]), fmt.block("{", "}", ["c", "d"])])
     self.assertEqual(str(data), "{ab},{cd}", "Failed to format sep/block")
     data = fmt.end(";\n", ["a", "b", "c"])
     self.assertEqual(str(data), "a;\nb;\nc;\n", "Failed to format a list end by ';\n'")
     data = fmt.tab(fmt.block("{\n", "}\n", ["a\n", "b\n", "c\n"]))
     self.assertEqual(
         str(data), (("{tab}{{\n{tab}a\n" + "{tab}b\n{tab}c\n{tab}}}\n")).format(tab=(" " * 4)), "Failed to indent"
     )
     data = fmt.block("{\n", "}\n", [fmt.tab(["a\n", "b\n", "c\n"])])
     self.assertEqual(
         str(data), (("{{\n{tab}a\n{tab}b\n" + "{tab}c\n}}\n")).format(tab=(" " * 4)), "Failed to indent"
     )
     data = fmt.block(
         "{\n",
         "}\n",
         [fmt.tab(fmt.end("\n", ["a", "b", fmt.tab(fmt.block("[\n", "]", ["b\n", "g\n", "o\n", "e\n"])), "c"]))],
     )
     self.assertEqual(
         str(data),
         (
             (
                 "{{\n{tab}a\n{tab}b\n"
                 + "{tab2}[\n{tab2}b\n{tab2}g\n"
                 + "{tab2}o\n{tab2}e\n{tab2}]\n"
                 + "{tab}c\n}}\n"
             )
         ).format(tab=(" " * 4), tab2=(" " * 8)),
         "Failed to indent",
     )
     data = fmt.block(
         "{\n",
         "}\n",
         [
             fmt.tab(
                 fmt.end(
                     "\n", ["a", "b", fmt.block("[\n", "]", [fmt.tab(fmt.tab(["b\n", "g\n", "o\n", "e\n"]))]), "c"]
                 )
             )
         ],
     )
     self.assertEqual(
         str(data),
         (
             ("{{\n{tab}a\n{tab}b\n" + "{tab}[\n{tab2}b\n{tab2}g\n" + "{tab2}o\n{tab2}e\n{tab}]\n" + "{tab}c\n}}\n")
         ).format(tab=(" " * 4), tab2=(" " * 12)),
         "Failed to indent",
     )
     data = fmt.block("{\n", "}\n", fmt.tab(["a\n", fmt.block("{\n", "}\n", fmt.tab(["d\n", "e\n", "f\n"])), "c\n"]))
     self.assertEqual(
         str(data),
         (("{{\n{tab}a\n" + "{tab}{{\n{tab2}d\n{tab2}e\n{tab2}f\n{tab}}}\n" + "{tab}c\n}}\n")).format(
             tab=(" " * 4), tab2=(" " * 8)
         ),
         "Failed to indent",
     )
     data = fmt.block("{\n", "}\n", fmt.tab(fmt.block("{\n", "}\n", fmt.tab(fmt.end(";\n", ["a", "b", "c"])))))
     self.assertEqual(
         str(data),
         (("{{\n{tab}{{\n" + "{tab2}a;\n{tab2}b;\n{tab2}c;\n" + "{tab}}}\n}}\n")).format(
             tab=(" " * 4), tab2=(" " * 8)
         ),
         "Failed to indent",
     )
     data = fmt.tab(["1", "2", [fmt.sep(",\n", ["tot", "tit", "tut"])], "4"])
     self.assertEqual(
         str(data), ("{tab}12tot,\n{tab}tit,\n" + "{tab}tut4").format(tab=" " * 4), "Failed to format end"
     )
Exemple #31
0
 def to_fmt(self) -> fmt.indentable:
     res = fmt.block('{\n', '}', [fmt.tab([])])
     lines = res.lsdata[0].lsdata
     for stmt in self.stmts:
         lines.append(fmt.end('\n', stmt.to_fmt()))
     return res
Exemple #32
0
def to_c(self):
    lsbody = []
    for e in self.body:
        if e is not None and hasattr(e, 'to_c'):
            lsbody.append(e.to_c())
    return fmt.block("({\n", "})", fmt.tab(lsbody))
Exemple #33
0
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):
            inner.lsdata.append(fmt.sep(", "[repr(subitem)]))
        if len(item) == 0:
            inner.lsdata.append("\n")
        pp.append(tag)
        return
    if item is None:
        tag = fmt.end('\n', [name])
        pp.append(tag)
        return
Exemple #34
0
def to_c(self):
    lsbody = []
    for e in self.body:
        if e is not None and hasattr(e, 'to_c'):
            lsbody.append(e.to_c())
    return fmt.block("({\n", "})", fmt.tab(lsbody))
Exemple #35
0
def to_cython(self, ctype_name: str) -> CStub:
    cstub = CStub()
    # SETUP GENERATION
    cstub.setup = fmt.end('', [])
    cstub.setup.lsdata.append(tpl_setup.substitute(
        ctn=ctype_name,
    ))
    # CSOURCE GENERATION
    pyattr = fmt.end('', [])
    pyxprotos = fmt.end('', [])
    pprotos = fmt.end('', [])
    cprotos = fmt.end('', [])
    gram = fmt.end('//---\n', [])
    gram.lsdata.append(tpl_file.substitute(ctn=ctype_name))
    for k, v in self.__class__._rules.items():
        try:
            if isinstance(v, parsing.Functor):
                genstate = GenState()
                fun_name = k.replace('.', '_')
                #
                if not isinstance(v, functors.Seq):
                    v = functors.Seq(v)
                rule_code = v.to_cython(genstate)
                content = tpl_function.substitute(
                    ctn=ctype_name,
                    rule=fun_name,
                    code=fmt.tab([rule_code]),
                    lvlid=genstate.lvlid,
                    errid=genstate.errid
                )
                rule = fmt.sep(
                               '\n',
                               [
                                "//--- %s" % k,
                                content
                               ]
                )
                pyattr.lsdata.append(tpl_python_attr.substitute(
                    rule=fun_name
                ))
                pprotos.lsdata.append(tpl_pproto.substitute(
                    ctn=ctype_name,
                    rule=fun_name
                ))
                cprotos.lsdata.append(tpl_cproto.substitute(
                    ctn=ctype_name,
                    rule=fun_name
                ))
                pyxprotos.lsdata.append(tpl_pyx_rules.substitute(
                    ctn=ctype_name,
                    rule=fun_name
                ))
                gram.lsdata.append(rule)
        except:
            #print("Can't Transform %s = %s" % (k, to_yml.to_yml(v)))
            pass
    cstub.csource = gram
    # PYTHON GENERATION
    cstub.psource = fmt.end('', [])
    cstub.psource.lsdata.append(tpl_python.substitute(
        ctn=ctype_name,
        rules_attr=str(pyattr)
    ))
    # CHEADER GENERATION
    cstub.cheader = fmt.end('', [])
    cstub.cheader.lsdata.append(tpl_header.substitute(
        ctn=ctype_name,
        cfunctions_proto=str(cprotos)
    ))
    # PXD GENERATION
    cstub.pxd = fmt.end('', [])
    cstub.pxd.lsdata.append(tpl_pxd.substitute(
        ctn=ctype_name,
        pfunctions_proto=str(pprotos)
    ))
    # PYX GENERATION
    cstub.pyx = fmt.end('', [])
    cstub.pyx.lsdata.append(tpl_pyx.substitute(
        ctn=ctype_name,
        rfunctions_proto=str(pyxprotos)
    ))
    return cstub
Exemple #36
0
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
    if hasattr(self, 'fields'):
        fields = []
        for field in self.fields:
            fields.append(field.to_c())
        decl_ls.lsdata.insert(0, fmt.tab(fmt.block("{\n", "}", fields)))
    # just the type name
    if hasattr(self, 'identifier'):
        decl_ls.lsdata.insert(0, self.identifier)
    # attributes composed
    if hasattr(self, '_attr_composed'):
        decl_ls.lsdata.insert(0, fmt.sep(" ", self._attr_composed))
    # specifier
    if self._specifier != nodes.Specifiers.AUTO:
        if self._specifier == nodes.Specifiers.LONGLONG:
            decl_ls.lsdata.insert(0, "long long")
        else:
            decl_ls.lsdata.insert(
                0,
                nodes.Specifiers.rmap[
                    self._specifier
                ].lower()
            )
    # sign
    if hasattr(self, '_sign') and self._sign != nodes.Signs.AUTO:
        decl_ls.lsdata.insert(0, nodes.Signs.rmap[self._sign].lower())
    # qualifier externalized
    if qualextern is not None:
        decl_ls.lsdata.insert(
            0,
            nodes.Qualifiers.rmap[
                qualextern._qualifier
            ].lower()
        )
    # End by storage
    if self._storage != nodes.Storages.AUTO:
        decl_ls.lsdata.insert(0, nodes.Storages.rmap[self._storage].lower())
    return decl_ls
Exemple #37
0
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):
            inner.lsdata.append(fmt.sep(", ", [repr(subitem)]))
        if len(item) == 0:
            inner.lsdata.append("\n")
        pp.append(tag)
        return
    if item is None:
        tag = fmt.end('\n', [name])
        pp.append(tag)
        return
Exemple #38
0
 def test_00(self):
     """Test pprint functions"""
     data = fmt.end(";", ["tot"])
     self.assertEqual(str(data), "tot;", "Failed to format end")
     data = fmt.tab(fmt.end(";\n", ["tot"]))
     self.assertEqual(str(data), "    tot;\n", "Failed to format end")
     data = fmt.tab([fmt.end(";\n", ["tot"])])
     self.assertEqual(str(data), "    tot;\n", "Failed to format end")
     data = fmt.end(";", ["", fmt.tab(["\ntot", "\nplop"])])
     self.assertEqual(str(data),
                      ";\n{tab}tot\n{tab}plop;".format(tab=" " * 4),
                      "Failed to format end")
     data = fmt.end(";", ["", fmt.tab(["\ntot", "\nplop"])])
     self.assertEqual(str(data),
                      ";\n{tab}tot\n{tab}plop;".format(tab=" " * 4),
                      "Failed to format end")
     data = fmt.sep(",", ['a', 'b', 'c'])
     self.assertEqual(str(data), "a,b,c", "Failed to format sep")
     data = fmt.tab(fmt.sep(",\n", ["tot", "tit", "tut"]))
     self.assertEqual(str(data),
                      "{tab}tot,\n{tab}tit,\n{tab}tut".format(tab=" " * 4),
                      "Failed to format end")
     data = fmt.sep(",\n", [fmt.tab(["tot", "tit"]), "tut"])
     self.assertEqual(str(data), "tottit,\ntut", "Failed to format end")
     data = fmt.block("{", "}", ['a', 'b', 'c'])
     self.assertEqual(str(data), "{abc}", "Failed to format block")
     data = fmt.block("{", "}", [fmt.sep(",", ['a', 'b', 'c'])])
     self.assertEqual(str(data), "{a,b,c}", "Failed to format block/sep")
     data = fmt.sep(
         ",",
         [fmt.block("{", "}", ['a', 'b']),
          fmt.block("{", "}", ['c', 'd'])])
     self.assertEqual(str(data), "{ab},{cd}", "Failed to format sep/block")
     data = fmt.end(";\n", ['a', 'b', 'c'])
     self.assertEqual(str(data), "a;\nb;\nc;\n",
                      "Failed to format a list end by ';\n'")
     data = fmt.tab(fmt.block("{\n", "}\n", ['a\n', 'b\n', 'c\n']))
     self.assertEqual(str(data),
                      (("{tab}{{\n{tab}a\n" +
                        "{tab}b\n{tab}c\n{tab}}}\n")).format(tab=(" " * 4)),
                      "Failed to indent")
     data = fmt.block("{\n", "}\n", [fmt.tab(['a\n', 'b\n', 'c\n'])])
     self.assertEqual(str(data), (("{{\n{tab}a\n{tab}b\n" +
                                   "{tab}c\n}}\n")).format(tab=(" " * 4)),
                      "Failed to indent")
     data = fmt.block("{\n", "}\n", [
         fmt.tab(
             fmt.end("\n", [
                 'a', 'b',
                 fmt.tab(fmt.block("[\n", "]",
                                   ['b\n', 'g\n', 'o\n', 'e\n'])), 'c'
             ]))
     ])
     self.assertEqual(
         str(data),
         (("{{\n{tab}a\n{tab}b\n" + "{tab2}[\n{tab2}b\n{tab2}g\n" +
           "{tab2}o\n{tab2}e\n{tab2}]\n" + "{tab}c\n}}\n")).format(
               tab=(" " * 4), tab2=(" " * 8)), "Failed to indent")
     data = fmt.block("{\n", "}\n", [
         fmt.tab(
             fmt.end("\n", [
                 'a', 'b',
                 fmt.block(
                     "[\n", "]",
                     [fmt.tab(fmt.tab(['b\n', 'g\n', 'o\n', 'e\n']))]), 'c'
             ]))
     ])
     self.assertEqual(
         str(data),
         (("{{\n{tab}a\n{tab}b\n" + "{tab}[\n{tab2}b\n{tab2}g\n" +
           "{tab2}o\n{tab2}e\n{tab}]\n" + "{tab}c\n}}\n")).format(
               tab=(" " * 4), tab2=(" " * 12)), "Failed to indent")
     data = fmt.block(
         "{\n", "}\n",
         fmt.tab([
             'a\n',
             fmt.block("{\n", "}\n", fmt.tab(['d\n', 'e\n', 'f\n'])), 'c\n'
         ]))
     self.assertEqual(str(data),
                      (("{{\n{tab}a\n" +
                        "{tab}{{\n{tab2}d\n{tab2}e\n{tab2}f\n{tab}}}\n" +
                        "{tab}c\n}}\n")).format(tab=(" " * 4),
                                                tab2=(" " * 8)),
                      "Failed to indent")
     data = fmt.block(
         "{\n", "}\n",
         fmt.tab(
             fmt.block("{\n", "}\n",
                       fmt.tab(fmt.end(";\n", ["a", "b", "c"])))))
     self.assertEqual(str(data),
                      (("{{\n{tab}{{\n" + "{tab2}a;\n{tab2}b;\n{tab2}c;\n" +
                        "{tab}}}\n}}\n")).format(tab=(" " * 4),
                                                 tab2=(" " * 8)),
                      "Failed to indent")
     data = fmt.tab(
         ["1", "2", [fmt.sep(",\n", ["tot", "tit", "tut"])], "4"])
     self.assertEqual(str(data), ("{tab}12tot,\n{tab}tit,\n" +
                                  "{tab}tut4").format(tab=" " * 4),
                      "Failed to format end")
Exemple #39
0
 def to_fmt(self) -> fmt.indentable:
     res = fmt.block('{\n', '}', [fmt.tab([])])
     lines = res.lsdata[0].lsdata
     for stmt in self.stmts:
         lines.append(fmt.end('\n', stmt.to_fmt()))
     return res