1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
import sys
import antlr
class Visitor(antlr.ASTVisitor):
def __init__(self,*args):
super(Visitor,self).__init__(*args)
self.level = 0
if not args:
self.cout = sys.stdout
return
if isinstance(args[0],file):
self.cout = args[0]
return
assert 0
def tabs(self):
print " " * self.level
def printf(self,fmt,*args):
if not args:
sys.stdout.write(fmt)
return
argv = tuple(args)
self.cout.write(fmt % argv)
def flush(self):
self.cout.flush()
def visit1(self,node):
if not node:
self.printf(" nil ")
return
c = node.getType()
t = node.getText()
k = node.getFirstChild()
s = node.getNextSibling()
self.printf("( <%s> ",c)
if t:
self.printf(" %s ",t)
self.visit1(k);
self.visit1(s);
self.printf(")")
def visit(self,node):
self.visit1(node);
self.printf("\n")
class CalcAST(antlr.BaseAST):
def __init__(self,*args):
antlr.BaseAST.__init__(self)
class BinaryOperatorAST(CalcAST):
def __init__(self,*args):
CalcAST.__init__(self,*args)
def left(self):
return self.getFirstChild()
def right(self):
t = self.left();
if not t: return None
return t.getNextSibling()
def c2(self):
t = self.left()
if t: t = t.getNextSibling()
assert t
return t
### A simple node to represent PLUS operation
class PLUSNode(BinaryOperatorAST):
def __init__(self,*args):
BinaryOperatorAST.__init__(self,*args)
### Compute value of subtree; this is heterogeneous part :)
def value(self):
left = self.left()
assert self
r = self.c2()
assert r
return left.value() + r.value()
def toString(self):
return " +";
def __str__(self):
return self.toString()
def __repr__(self):
return str(self)
### A simple node to represent MULT operation
class MULTNode(BinaryOperatorAST):
def __init__(self,*args):
BinaryOperatorAST.__init__(self,*args)
# Compute value of subtree; this is heterogeneous part :)
def value(self):
return self.left().value() * self.c2().value()
def toString(self):
return " *";
def __str__(self):
return self.toString()
def __repr__(self):
return str(self)
### A simple node to represent an INT
class INTNode(CalcAST):
def __init__(self,*args):
CalcAST.__init__(self,*args)
self.v = 0
if args and isinstance(args[0],antlr.Token):
self.v = int(args[0].getText())
# Compute value of subtree; this is heterogeneous part :)
def value(self):
return self.v
def toString(self):
return " " + str(self.v)
def main():
import hetero_l
import hetero_p
L = hetero_l.Lexer()
P = hetero_p.Parser(L)
P.setFilename(L.getFilename())
### Parse the input expression
try:
P.expr()
except antlr.ANTLRException, ex:
print "*** error(s) while parsing."
print ">>> exit(1)"
import sys
sys.exit(1)
ast = P.getAST()
if not ast:
print "stop - no AST generated."
import sys
sys.exit(1)
###show tree
print "Tree: " + ast.toStringTree()
print "List: " + ast.toStringList()
print "Node: " + ast.toString()
print "visit>>"
visitor = Visitor()
visitor.visit(ast);
print "visit<<"
### compute value and return
r = ast.value()
print "value is", r
if __name__ == "__main__":
main()
|
