← Back to branch summary

~ubuntu-branches/ubuntu/karmic/pypy/karmic

« back to all changes in this revision

Viewing changes to pypy/lang/prolog/interpreter/translatedmain.py

  • Committer: Bazaar Package Importer
  • Author(s): Alexandre Fayolle
  • Date: 2007-04-13 09:33:09 UTC
  • Revision ID: james.westby@ubuntu.com-20070413093309-yoojh4jcoocu2krz
Tags: upstream-1.0.0
Import upstream version 1.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
pypy/lang/prolog/interpreter/translatedmain.py
 
1
import os, sys
 
2
from pypy.rlib.parsing.parsing import ParseError
 
3
from pypy.rlib.parsing.deterministic import LexerError
 
4
from pypy.lang.prolog.interpreter.interactive import helptext
 
5
from pypy.lang.prolog.interpreter.parsing import parse_file, get_query_and_vars
 
6
from pypy.lang.prolog.interpreter.parsing import get_engine
 
7
from pypy.lang.prolog.interpreter.engine import Engine
 
8
from pypy.lang.prolog.interpreter.engine import Continuation
 
9
from pypy.lang.prolog.interpreter import error, term
 
10
import pypy.lang.prolog.interpreter.term
 
11
pypy.lang.prolog.interpreter.term.DEBUG = False
 
12
 
 
13
 
 
14
class StopItNow(Exception):
 
15
    pass
 
16
 
 
17
class ContinueContinuation(Continuation):
 
18
    def __init__(self, var_to_pos, write):
 
19
        self.var_to_pos = var_to_pos
 
20
        self.write = write
 
21
 
 
22
    def call(self, engine):
 
23
        self.write("yes\n")
 
24
        var_representation(self.var_to_pos, engine, self.write)
 
25
        while 1:
 
26
            res = getch()
 
27
            #self.write(res+"\n")
 
28
            if res in "\r\x04\n":
 
29
                self.write("\n")
 
30
                raise StopItNow()
 
31
            if res in ";nr":
 
32
                raise error.UnificationFailed
 
33
            elif res in "h?":
 
34
                self.write(helptext)
 
35
            elif res in "p":
 
36
                var_representation(self.var_to_pos, engine, self.write)
 
37
            else:
 
38
                self.write('unknown action. press "h" for help\n')
 
39
 
 
40
def var_representation(var_to_pos, engine, write):
 
41
    from pypy.lang.prolog.builtin import formatting
 
42
    f = formatting.TermFormatter(engine, quoted=True, max_depth=20)
 
43
    for var, real_var in var_to_pos.iteritems():
 
44
        if var.startswith("_"):
 
45
            continue
 
46
        val = f.format(real_var.getvalue(engine.frame))
 
47
        write("%s = %s\n" % (var, val))
 
48
 
 
49
def getch():
 
50
    line = readline()
 
51
    return line[0]
 
52
 
 
53
def debug(msg):
 
54
    os.write(2, "debug: " + msg + '\n')
 
55
 
 
56
def printmessage(msg):
 
57
    os.write(1, msg)
 
58
 
 
59
def readline():
 
60
    result = []
 
61
    while 1:
 
62
        s = os.read(0, 1)
 
63
        result.append(s)
 
64
        if s == "\n":
 
65
            break
 
66
        if s == '':
 
67
            if len(result) > 1:
 
68
                break
 
69
            raise SystemExit
 
70
    return "".join(result)
 
71
 
 
72
def run(goal, var_to_pos, e):
 
73
    from pypy.lang.prolog.interpreter.error import UnificationFailed, CatchableError
 
74
    from pypy.lang.prolog.interpreter.error import UncatchableError, UserError
 
75
    from pypy.lang.prolog.builtin import formatting
 
76
    f = formatting.TermFormatter(e, quoted=True, max_depth=20)
 
77
    try:
 
78
        e.run(goal, ContinueContinuation(var_to_pos, printmessage))
 
79
    except UnificationFailed:
 
80
        printmessage("no\n")
 
81
    except UncatchableError, e:
 
82
        printmessage("INTERNAL ERROR: %s\n" % (e.message, ))
 
83
    except UserError, e:
 
84
        printmessage("ERROR: ")
 
85
        f._make_reverse_op_mapping()
 
86
        printmessage("Unhandled exception: ")
 
87
        printmessage(f.format(e.term))
 
88
    except CatchableError, e:
 
89
        f._make_reverse_op_mapping()
 
90
        printmessage("ERROR: ")
 
91
        t = e.term
 
92
        if isinstance(t, term.Term):
 
93
            errorterm = t.args[0]
 
94
            if isinstance(errorterm, term.Callable):
 
95
                if errorterm.name == "instantiation_error":
 
96
                    printmessage("arguments not sufficiently instantiated\n")
 
97
                    return
 
98
                elif errorterm.name == "existence_error":
 
99
                    if isinstance(errorterm, term.Term):
 
100
                        printmessage("Undefined %s: %s\n" % (
 
101
                            f.format(errorterm.args[0]),
 
102
                            f.format(errorterm.args[1])))
 
103
                        return
 
104
                elif errorterm.name == "domain_error":
 
105
                    if isinstance(errorterm, term.Term):
 
106
                        printmessage(
 
107
                            "Domain error: '%s' expected, found '%s'\n" % (
 
108
                            f.format(errorterm.args[0]),
 
109
                            f.format(errorterm.args[1])))
 
110
                        return
 
111
                elif errorterm.name == "type_error":
 
112
                    if isinstance(errorterm, term.Term):
 
113
                        printmessage(
 
114
                            "Type error: '%s' expected, found '%s'\n" % (
 
115
                            f.format(errorterm.args[0]),
 
116
                            f.format(errorterm.args[1])))
 
117
                        return
 
118
        printmessage(" (but I cannot tell you which one)\n")
 
119
    except StopItNow:
 
120
        pass
 
121
    else:
 
122
        printmessage("yes\n")
 
123
 
 
124
def repl(engine):
 
125
    printmessage("welcome!\n")
 
126
    while 1:
 
127
        printmessage(">?- ")
 
128
        line = readline()
 
129
        if line == "halt.\n":
 
130
            break
 
131
        try:
 
132
            goals, var_to_pos = engine.parse(line)
 
133
        except ParseError, exc:
 
134
            printmessage(exc.nice_error_message("<stdin>", line) + "\n")
 
135
            continue
 
136
        except LexerError, exc:
 
137
            printmessage(exc.nice_error_message("<stdin>") + "\n")
 
138
            continue
 
139
        for goal in goals:
 
140
            run(goal, var_to_pos, engine)
 
141
 
 
142
def execute(e, filename):
 
143
    e.run(term.Term("consult", [term.Atom(filename)]))
 
144
 
 
145
if __name__ == '__main__':
 
146
    e = Engine()
 
147
    repl(e)