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):
"""
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_c(self):
return fmt.sep(
"",
[
self.call_expr.to_c(), # expr
fmt.block('[', ']', [self.params[0].to_c()]) # index
])
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_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_fmt(self) -> fmt.indentable:
index = '*'
if self.idx is not None:
index = str(self.idx)
res = fmt.block('[' + index + ': ', ']', [])
res.lsdata.append(self.v.to_fmt())
return res
def to_fmt(self) -> fmt.indentable:
index = '*'
if self.idx is not None:
index = str(self.idx)
res = fmt.block('[' + index + ': ', ']', [])
res.lsdata.append(self.v.to_fmt())
return res
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:
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_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_c(self):
lsparams = []
# TODO: add forward declarations
for p in self.params:
lsparams.append(p.to_c())
return fmt.sep("", [
self.call_expr.to_c(),
fmt.block('(', ')', [fmt.sep(', ', lsparams)])
])
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_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)
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_c(self):
if isinstance(self.params[0], nodes.CType):
return fmt.sep(
" ",
[
self.call_expr.to_c(), # sizeof/typeof ...
fmt.block("(", ")", self.params[0].ctype_to_c()) # type/expr
])
else:
return fmt.sep(" ", [self.call_expr.to_c(), self.params[0].to_c()])
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_c(self):
if isinstance(self.params[0], nodes.CType):
return fmt.sep(
" ",
[
self.call_expr.to_c(), # sizeof/typeof ...
fmt.block("(", ")", self.params[0].ctype_to_c()) # type/expr
]
)
else:
return fmt.sep(" ", [self.call_expr.to_c(), self.params[0].to_c()])
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 = 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_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)
def to_c(self):
return fmt.sep(
" ",
[
fmt.block(
"(",
")",
self.params[0].ctype_to_c() # type
),
self.params[1].to_c() # expr
])
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:
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_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)
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_c(self):
return fmt.sep(
" ",
[
fmt.block(
"(",
")",
self.params[0].ctype_to_c() # type
),
self.params[1].to_c() # expr
]
)
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_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)
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_tl4t(self) -> fmt.indentable:
params = []
if self.p is not None:
for p in self.p:
params.append(p.to_tl4t())
parenth = fmt.block('(', ')', fmt.sep(", ", params))
lsdecl = fmt.sep(
' ', ["fun", fmt.sep('', [self.name, parenth]), ":", self.t])
lsblock = None
if hasattr(self, 'block'):
lsblock = fmt.sep("\n", [lsdecl, self.block.to_tl4t()])
else:
lsblock = fmt.end(";\n", lsdecl)
return lsblock
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)
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
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
def to_fmt(self) -> fmt.indentable:
lsub = []
txtfinal = fmt.sep(".", lsub)
lself = []
txtself = fmt.sep("", lself)
lself.append(self.__name.to_fmt())
if len(self.__params) > 0:
lsp = []
for p in self.__params:
lsp.append(p.to_fmt())
txtparams = fmt.block("<", ">", lsp)
lself.append(txtparams)
lsub.append(lself)
if self.__subcomponent is not None:
lsub.append(self.__subcomponent.to_fmt())
return txtfinal
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)))
def to_fmt(self) -> fmt.indentable:
lsub = []
txtfinal = fmt.sep(".", lsub)
lself = []
txtself = fmt.sep("", lself)
lself.append(self.__name.to_fmt())
if len(self.__params) > 0:
lsp = []
for p in self.__params:
lsp.append(p.to_fmt())
txtparams = fmt.block("<", ">", lsp)
lself.append(txtparams)
lsub.append(lself)
if self.__subcomponent is not None:
lsub.append(self.__subcomponent.to_fmt())
return txtfinal
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)))
def to_c(self):
lsparams = []
# TODO: add forward declarations
for p in self.params:
lsparams.append(p.to_c())
return fmt.sep(
"",
[
self.call_expr.to_c(),
fmt.block(
'(',
')',
[fmt.sep(', ', lsparams)]
)
]
)
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
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
def to_tl4t(self) -> fmt.indentable:
params = []
if self.p is not None:
for p in self.p:
params.append(p.to_tl4t())
parenth = fmt.block('(', ')', fmt.sep(", ", params))
lsdecl = fmt.sep(
' ',
[
"fun",
fmt.sep('', [self.name, parenth]),
":",
self.t
]
)
lsblock = None
if hasattr(self, 'block'):
lsblock = fmt.sep("\n", [lsdecl, self.block.to_tl4t()])
else:
lsblock = fmt.end(";\n", lsdecl)
return lsblock
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)
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)
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")
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))
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
def to_c(self):
return fmt.block('(', ')', [self.params[0].to_c()])
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
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
def to_tl4t(self):
return fmt.block("(", ")", [self.p[0].to_tl4t()])
def to_fmt(self) -> fmt.indentable:
res = fmt.block('(', ')', [self.subexpr.to_fmt()])
return res
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
def to_tl4t(self):
return fmt.block("(", ")", [self.p[0].to_tl4t()])
def to_fmt(self) -> fmt.indentable:
res = fmt.block('(', ')', [self.subexpr.to_fmt()])
return res
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
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
