|
148
|
1 """
|
|
|
2 AST nodes for the c3 language.
|
|
|
3 """
|
|
|
4
|
|
|
5 class Node:
|
|
|
6 location = None
|
|
|
7 def getChildren(self):
|
|
|
8 children = []
|
|
|
9 members = dir(self)
|
|
|
10 for member in members:
|
|
|
11 member = getattr(self, member)
|
|
|
12 if isinstance(member, Node):
|
|
|
13 children.append(member)
|
|
|
14 elif type(member) is list:
|
|
|
15 for mi in member:
|
|
|
16 if isinstance(mi, Node):
|
|
|
17 children.append(mi)
|
|
|
18 return children
|
|
|
19
|
|
|
20
|
|
|
21 class Id(Node):
|
|
|
22 def __init__(self, tok, pub):
|
|
|
23 self.name = tok.val
|
|
|
24 self.is_public = pub
|
|
|
25 def __repr__(self):
|
|
|
26 return 'ID {0}'.format(self.name)
|
|
|
27
|
|
|
28 # Selectors:
|
|
|
29 class Designator(Node):
|
|
|
30 def __init__(self, obj, selectors, typ):
|
|
|
31 self.obj = obj
|
|
|
32 self.selectors = selectors
|
|
|
33 self.typ = typ
|
|
|
34 def __repr__(self):
|
|
|
35 return 'DESIGNATOR {0}, selectors {1}, type {2}'.format(self.obj, self.selectors, self.typ)
|
|
|
36
|
|
|
37 """
|
|
|
38 Type classes
|
|
|
39 """
|
|
|
40 def isType(a, b):
|
|
|
41 """ Compare types a and b and check if they are equal """
|
|
|
42 if type(a) is type(b):
|
|
|
43 if type(a) is BaseType:
|
|
|
44 return (a.name == b.name) and (a.size == b.size)
|
|
|
45 elif type(a) is ProcedureType:
|
|
|
46 if len(a.parameters) != len(b.parameters):
|
|
|
47 print('Number of parameters does not match')
|
|
|
48 return False
|
|
|
49 for aparam, bparam in zip(a.parameters, b.parameters):
|
|
|
50 if not isType(aparam.typ, bparam.typ):
|
|
|
51 print('Parameter {0} does not match parameter {1}'.format(aparam, bparam))
|
|
|
52 return False
|
|
|
53 if a.result is None:
|
|
|
54 # TODO: how to handle a None return type??
|
|
|
55 pass
|
|
|
56 if not isType(a.result, b.result):
|
|
|
57 print('Procedure return value mismatch {0} != {1}'.format(a.result, b.result))
|
|
|
58 return False
|
|
|
59 return True
|
|
|
60 else:
|
|
|
61 print(a)
|
|
|
62 print(b)
|
|
|
63 Error('Not implemented {0}'.format(a))
|
|
|
64 else:
|
|
|
65 return False
|
|
|
66
|
|
|
67 class Type:
|
|
|
68 def isType(self, b):
|
|
|
69 return isType(self, b)
|
|
|
70
|
|
|
71 class BaseType(Type):
|
|
|
72 def __init__(self, name):
|
|
|
73 self.name = name
|
|
|
74 def __repr__(self):
|
|
|
75 return '[TYPE {0}]'.format(self.name)
|
|
|
76
|
|
|
77 class FunctionType(Type):
|
|
|
78 def __init__(self, parameters, returntype):
|
|
|
79 self.parameters = parameters
|
|
|
80 self.returntype = returntype
|
|
|
81 def __repr__(self):
|
|
|
82 return '[PROCTYPE {0} RET {1}]'.format(self.parameters, self.returntype)
|
|
|
83
|
|
|
84 class DefinedType(Type):
|
|
|
85 def __init__(self, name, typ):
|
|
|
86 self.name = name
|
|
|
87 self.typ = typ
|
|
|
88 def __repr__(self):
|
|
|
89 return 'Named type {0} of type {1}'.format(self.name, self.typ)
|
|
|
90
|
|
|
91 # Variables, parameters, local variables, constants:
|
|
|
92 class Symbol(Node):
|
|
|
93 pass
|
|
|
94
|
|
|
95 class Constant(Symbol):
|
|
|
96 def __init__(self, value, typ, name=None, public=False):
|
|
|
97 self.name = name
|
|
|
98 self.value = value
|
|
|
99 self.typ = typ
|
|
|
100 self.public = public
|
|
|
101 def __repr__(self):
|
|
|
102 return 'CONSTANT {0} = {1}'.format(self.name, self.value)
|
|
|
103
|
|
|
104 class Variable(Symbol):
|
|
|
105 def __init__(self, name, typ, public):
|
|
|
106 self.name = name
|
|
|
107 self.typ = typ
|
|
|
108 self.public = public
|
|
|
109 self.isLocal = False
|
|
|
110 self.isReadOnly = False
|
|
|
111 self.isParameter = False
|
|
|
112 def __repr__(self):
|
|
|
113 txt = '[public] ' if self.public else ''
|
|
|
114 return '{2}VAR {0} : {1}'.format(self.name, self.typ, txt)
|
|
|
115
|
|
|
116 class Parameter(Node):
|
|
|
117 """ A parameter has a passing method, name and typ """
|
|
|
118 def __init__(self, name, typ):
|
|
|
119 self.name = name
|
|
|
120 self.typ = typ
|
|
|
121 def __repr__(self):
|
|
|
122 return 'PARAM {0} {1}'.format(self.name, self.typ)
|
|
|
123
|
|
|
124 # Operations:
|
|
|
125 class Unop(Node):
|
|
|
126 def __init__(self, a, op):
|
|
|
127 self.a = a
|
|
|
128 self.op = op
|
|
|
129 def __repr__(self):
|
|
|
130 return 'UNOP {0}'.format(self.op)
|
|
|
131
|
|
|
132 class Binop(Node):
|
|
|
133 def __init__(self, a, op, b):
|
|
|
134 self.a = a
|
|
|
135 self.b = b
|
|
|
136 self.op = op # Operation: '+', '-', '*', '/', 'mod'
|
|
|
137 def __repr__(self):
|
|
|
138 return 'BINOP {0} {1}'.format(self.op, self.typ)
|
|
|
139
|
|
|
140 # Modules
|
|
|
141 class Package(Node):
|
|
|
142 def __init__(self, name):
|
|
|
143 self.name = name
|
|
|
144 def __repr__(self):
|
|
|
145 return 'PACKAGE {0}'.format(self.name)
|
|
|
146
|
|
|
147 # Procedure types
|
|
|
148 class Procedure(Symbol):
|
|
|
149 """ Actual implementation of a function """
|
|
|
150 def __init__(self, name, typ, block):
|
|
|
151 self.name = name
|
|
|
152 self.block = block
|
|
|
153 self.typ = typ
|
|
|
154 def __repr__(self):
|
|
|
155 return 'PROCEDURE {0} {1}'.format(self.name, self.typ)
|
|
|
156
|
|
|
157 # Statements
|
|
|
158 class CompoundStatement(Node):
|
|
|
159 def __init__(self, statements):
|
|
|
160 self.statements = statements
|
|
|
161 def __repr__(self):
|
|
|
162 return 'COMPOUND STATEMENT'
|
|
|
163
|
|
|
164 class EmptyStatement(Node):
|
|
|
165 def __repr__(self):
|
|
|
166 return 'EMPTY STATEMENT'
|
|
|
167
|
|
|
168 class Assignment(Node):
|
|
|
169 def __init__(self, lval, rval):
|
|
|
170 self.lval = lval
|
|
|
171 self.rval = rval
|
|
|
172 def __repr__(self):
|
|
|
173 return 'ASSIGNMENT'
|
|
|
174
|
|
|
175 class ProcedureCall(Node):
|
|
|
176 def __init__(self, proc, args):
|
|
|
177 self.proc = proc
|
|
|
178 self.args = args
|
|
|
179 def __repr__(self):
|
|
|
180 return 'CALL {0} '.format(self.proc)
|
|
|
181
|
|
|
182 class IfStatement(Node):
|
|
|
183 def __init__(self, condition, truestatement, falsestatement=None):
|
|
|
184 self.condition = condition
|
|
|
185 self.truestatement = truestatement
|
|
|
186 self.falsestatement = falsestatement
|
|
|
187 def __repr__(self):
|
|
|
188 return 'IF-statement'
|
|
|
189
|
|
|
190 class WhileStatement(Node):
|
|
|
191 def __init__(self, condition, statements):
|
|
|
192 self.condition = condition
|
|
|
193 self.dostatements = statements
|
|
|
194 def __repr__(self):
|
|
|
195 return 'WHILE-statement'
|
|
|
196
|
