|
148
|
1 """
|
|
213
|
2 AST (abstract syntax tree) nodes for the c3 language.
|
|
|
3 The tree is build by the parser.
|
|
|
4 Then it is checked
|
|
|
5 Finally code is generated from it.
|
|
148
|
6 """
|
|
|
7
|
|
|
8 class Node:
|
|
163
|
9 pass
|
|
148
|
10
|
|
213
|
11 # Modules
|
|
|
12 class Package(Node):
|
|
|
13 def __init__(self, name, loc):
|
|
|
14 self.name = name
|
|
|
15 self.loc = loc
|
|
|
16 self.declarations = []
|
|
|
17 def __repr__(self):
|
|
|
18 return 'PACKAGE {}'.format(self.name)
|
|
|
19
|
|
150
|
20 class Designator(Node):
|
|
213
|
21 def __init__(self, tname, loc):
|
|
|
22 self.tname = tname
|
|
|
23 self.loc = loc
|
|
|
24 def __repr__(self):
|
|
|
25 return 'DESIGNATOR {}'.format(self.tname)
|
|
148
|
26
|
|
|
27 """
|
|
|
28 Type classes
|
|
213
|
29
|
|
|
30 types must be comparable.
|
|
|
31
|
|
|
32 There are the following types:
|
|
|
33 - base type
|
|
|
34 - struct type
|
|
|
35 - pointer type
|
|
|
36 - typedef type
|
|
|
37 - function type
|
|
148
|
38 """
|
|
|
39
|
|
149
|
40 class Type(Node):
|
|
148
|
41 def isType(self, b):
|
|
|
42 return isType(self, b)
|
|
|
43
|
|
|
44 class BaseType(Type):
|
|
|
45 def __init__(self, name):
|
|
|
46 self.name = name
|
|
|
47 def __repr__(self):
|
|
212
|
48 return '{}'.format(self.name)
|
|
148
|
49
|
|
|
50 class FunctionType(Type):
|
|
167
|
51 def __init__(self, parametertypes, returntype):
|
|
|
52 self.parametertypes = parametertypes
|
|
148
|
53 self.returntype = returntype
|
|
|
54 def __repr__(self):
|
|
167
|
55 params = ', '.join([str(v) for v in self.parametertypes])
|
|
165
|
56 return '{1} f({0})'.format(params, self.returntype)
|
|
148
|
57
|
|
213
|
58 class PointerType(Type):
|
|
|
59 def __init__(self, ptype):
|
|
|
60 self.ptype = ptype
|
|
|
61
|
|
|
62 class StructureType(Type):
|
|
|
63 def __init__(self, mems):
|
|
|
64 self.mems = mems
|
|
|
65
|
|
148
|
66 class DefinedType(Type):
|
|
|
67 def __init__(self, name, typ):
|
|
|
68 self.name = name
|
|
|
69 self.typ = typ
|
|
|
70 def __repr__(self):
|
|
|
71 return 'Named type {0} of type {1}'.format(self.name, self.typ)
|
|
|
72
|
|
|
73 # Variables, parameters, local variables, constants:
|
|
|
74 class Symbol(Node):
|
|
213
|
75 def __init__(self, name):
|
|
163
|
76 self.name = name
|
|
|
77 self.refs = []
|
|
213
|
78 def addRef(self, r):
|
|
163
|
79 self.refs.append(r)
|
|
213
|
80 @property
|
|
|
81 def References(self):
|
|
163
|
82 return self.refs
|
|
148
|
83
|
|
|
84 class Constant(Symbol):
|
|
213
|
85 def __init__(self, name, typ, value):
|
|
163
|
86 super().__init__(name)
|
|
|
87 self.typ = typ
|
|
148
|
88 self.value = value
|
|
213
|
89 def __repr__(self):
|
|
148
|
90 return 'CONSTANT {0} = {1}'.format(self.name, self.value)
|
|
|
91
|
|
|
92 class Variable(Symbol):
|
|
213
|
93 def __init__(self, name, typ):
|
|
163
|
94 super().__init__(name)
|
|
148
|
95 self.typ = typ
|
|
213
|
96 self.ival = None
|
|
148
|
97 self.isLocal = False
|
|
|
98 self.isReadOnly = False
|
|
|
99 self.isParameter = False
|
|
|
100 def __repr__(self):
|
|
212
|
101 return '{}'.format(self.name)
|
|
148
|
102
|
|
150
|
103 # Procedure types
|
|
|
104 class Function(Symbol):
|
|
213
|
105 """ Actual implementation of a function """
|
|
|
106 def __init__(self, name, loc):
|
|
|
107 super().__init__(name)
|
|
|
108 self.loc = loc
|
|
215
|
109 self.declarations = []
|
|
213
|
110
|
|
|
111 def __repr__(self):
|
|
|
112 return '{}'.format(self.name)
|
|
148
|
113
|
|
163
|
114 # Operations / Expressions:
|
|
148
|
115 class Unop(Node):
|
|
|
116 def __init__(self, a, op):
|
|
|
117 self.a = a
|
|
|
118 self.op = op
|
|
|
119 def __repr__(self):
|
|
212
|
120 return 'UNOP {}'.format(self.op)
|
|
148
|
121
|
|
|
122 class Binop(Node):
|
|
213
|
123 def __init__(self, a, op, b, loc):
|
|
148
|
124 self.a = a
|
|
|
125 self.b = b
|
|
|
126 self.op = op # Operation: '+', '-', '*', '/', 'mod'
|
|
213
|
127 self.loc = loc
|
|
148
|
128 def __repr__(self):
|
|
212
|
129 return 'BINOP {}'.format(self.op)
|
|
148
|
130
|
|
150
|
131 class VariableUse(Node):
|
|
213
|
132 def __init__(self, target, loc):
|
|
150
|
133 self.target = target
|
|
213
|
134 self.loc = loc
|
|
150
|
135 def __repr__(self):
|
|
163
|
136 nm = self.target.name if hasattr(self.target, 'name') else ''
|
|
212
|
137 return 'VAR USE {}'.format(nm)
|
|
163
|
138
|
|
|
139 class Literal(Node):
|
|
213
|
140 def __init__(self, val, loc):
|
|
163
|
141 self.val = val
|
|
213
|
142 self.loc = loc
|
|
163
|
143 def __repr__(self):
|
|
212
|
144 return 'LITERAL {}'.format(self.val)
|
|
150
|
145
|
|
148
|
146
|
|
|
147 # Statements
|
|
|
148 class CompoundStatement(Node):
|
|
|
149 def __init__(self, statements):
|
|
|
150 self.statements = statements
|
|
|
151 def __repr__(self):
|
|
|
152 return 'COMPOUND STATEMENT'
|
|
|
153
|
|
155
|
154 class EmptyStatement(Node):
|
|
158
|
155 def __repr__(self):
|
|
|
156 return 'NOP'
|
|
155
|
157
|
|
149
|
158 class ReturnStatement(Node):
|
|
|
159 def __init__(self, expr):
|
|
|
160 self.expr = expr
|
|
148
|
161 def __repr__(self):
|
|
149
|
162 return 'RETURN STATEMENT'
|
|
148
|
163
|
|
|
164 class Assignment(Node):
|
|
213
|
165 def __init__(self, lval, rval, loc):
|
|
148
|
166 self.lval = lval
|
|
|
167 self.rval = rval
|
|
213
|
168 self.loc = loc
|
|
148
|
169 def __repr__(self):
|
|
|
170 return 'ASSIGNMENT'
|
|
|
171
|
|
167
|
172 class FunctionCall(Node):
|
|
213
|
173 def __init__(self, proc, args, loc):
|
|
148
|
174 self.proc = proc
|
|
|
175 self.args = args
|
|
213
|
176 self.loc = loc
|
|
148
|
177 def __repr__(self):
|
|
|
178 return 'CALL {0} '.format(self.proc)
|
|
|
179
|
|
|
180 class IfStatement(Node):
|
|
213
|
181 def __init__(self, condition, truestatement, falsestatement, loc):
|
|
148
|
182 self.condition = condition
|
|
|
183 self.truestatement = truestatement
|
|
|
184 self.falsestatement = falsestatement
|
|
213
|
185 self.loc = loc
|
|
148
|
186 def __repr__(self):
|
|
|
187 return 'IF-statement'
|
|
|
188
|
|
|
189 class WhileStatement(Node):
|
|
213
|
190 def __init__(self, condition, statement, loc):
|
|
148
|
191 self.condition = condition
|
|
213
|
192 self.statement = statement
|
|
|
193 self.loc = loc
|
|
148
|
194 def __repr__(self):
|
|
|
195 return 'WHILE-statement'
|
|
|
196
|
