def test_atom_formatting():
f = formatting.TermFormatter(Engine(), quoted=False, ignore_ops=False)
t = parse_query_term("'abc def'.")
assert f.format(t) == "abc def"
f = formatting.TermFormatter(Engine(), quoted=True, ignore_ops=False)
t = parse_query_term("'abc def'.")
assert f.format(t) == "'abc def'"
t = parse_query_term("abc.")
assert f.format(t) == "abc"
def test_op_formatting():
f = formatting.TermFormatter(Engine(), quoted=False, ignore_ops=False)
t = parse_query_term("'+'(1, 2).")
assert f.format(t) == "1+2"
t = parse_query_term("'+'(1, *(3, 2)).")
assert f.format(t) == "1+3*2"
t = parse_query_term("'*'(1, *(3, 2)).")
assert f.format(t) == "1*(3*2)"
def get_errstr(self, engine):
from prolog.builtin import formatting
from prolog.interpreter import term, signature
errorsig = signature.Signature.getsignature("error", 1)
f = formatting.TermFormatter(engine, quoted=True, max_depth=20)
f._make_reverse_op_mapping()
t = self.term
if not isinstance(t, term.Callable) or not t.signature().eq(errorsig):
return "Unhandled exception: %s" % (f.format(t), )
errorterm = t.argument_at(0)
if isinstance(errorterm, term.Callable):
if errorterm.name() == "instantiation_error":
return "arguments not sufficiently instantiated"
elif errorterm.name() == "existence_error":
if isinstance(errorterm, term.Callable):
return "Undefined %s: %s" % (
f.format(errorterm.argument_at(0)),
f.format(errorterm.argument_at(1)))
elif errorterm.name() == "domain_error":
if isinstance(errorterm, term.Callable):
return "Domain error: '%s' expected, found '%s'" % (
f.format(errorterm.argument_at(0)),
f.format(errorterm.argument_at(1)))
elif errorterm.name() == "type_error":
if isinstance(errorterm, term.Callable):
return "Type error: '%s' expected, found '%s'" % (
f.format(errorterm.argument_at(0)),
f.format(errorterm.argument_at(1)))
elif errorterm.name() == "syntax_error":
if isinstance(errorterm, term.Callable):
return "Syntax error: '%s'" % \
f.format(errorterm.argument_at(0))
elif errorterm.name() == "permission_error":
if isinstance(errorterm, term.Callable):
return "Permission error: '%s', '%s', '%s'" % (
f.format(errorterm.argument_at(0)),
f.format(errorterm.argument_at(1)),
f.format(errorterm.argument_at(2)))
elif errorterm.name() == "representation_error":
if isinstance(errorterm, term.Callable):
return "%s: Cannot represent: %s" % (
f.format(errorterm.argument_at(0)),
f.format(errorterm.argument_at(1)))
elif errorterm.name() == "import_error":
if isinstance(errorterm, term.Callable):
return "Exported procedure %s:%s is not defined" % (
f.format(errorterm.argument_at(0)),
f.format(errorterm.argument_at(1)))
else:
return "Internal error" # AKA, I have no clue what went wrong.
def var_representation(var_to_pos, engine, write, heap):
from prolog.builtin import formatting
f = formatting.TermFormatter(engine, quoted=True, max_depth=20)
for var, real_var in var_to_pos.iteritems():
if var.startswith("_"):
continue
value = real_var.dereference(heap)
val = f.format(value)
if isinstance(value, term.AttVar):
write("%s\n" % val)
else:
write("%s = %s\n" % (var, val))
def test_list():
f = formatting.TermFormatter(Engine(), quoted=False, ignore_ops=False)
t = parse_query_term("[1, 2, 3, 4, 5 | X].")
assert f.format(t) == "[1, 2, 3, 4, 5|_G0]"
t = parse_query_term("[a, b, 'A$%%$$'|[]].")
assert f.format(t) == "[a, b, A$%%$$]"
t = parse_query_term("'.'(a, b, c).")
assert f.format(t) == ".(a, b, c)"
X = BindingVar()
a = Callable.build('a')
t = Callable.build(".", [a, X])
X.binding = Callable.build(".", [a, Callable.build("[]")])
assert f.format(t) == "[a, a]"