Mercurial > lcfOS
annotate python/c3/typecheck.py @ 230:88a1e0baef65
Added some tests for IR-code
author | Windel Bouwman |
---|---|
date | Sat, 13 Jul 2013 19:53:44 +0200 |
parents | 7f18ed9b6b7e |
children | 521567d17388 |
rev | line source |
---|---|
163 | 1 from .astnodes import * |
2 from .scope import * | |
3 from .visitor import Visitor | |
4 | |
230 | 5 def resolveType(t): |
6 if type(t) is DefinedType: | |
7 return resolveType(t.typ) | |
8 return t | |
9 | |
163 | 10 def equalTypes(a, b): |
230 | 11 """ |
228 | 12 Compare types a and b for equality. |
13 Not equal until proven otherwise. | |
14 """ | |
226 | 15 # Recurse into named types: |
230 | 16 a = resolveType(a) |
17 b = resolveType(b) | |
18 | |
226 | 19 # Compare for structural equivalence: |
20 if type(a) is type(b): | |
21 if type(a) is BaseType: | |
22 return a.name == b.name | |
23 elif type(a) is PointerType: | |
24 return equalTypes(a.ptype, b.ptype) | |
227 | 25 elif type(a) is StructureType: |
26 if len(a.mems) != len(b.mems): | |
27 return False | |
28 for amem, bmem in zip(a.mems, b.mems): | |
29 if not equalTypes(amem.typ, bmem.typ): | |
30 return False | |
31 return True | |
32 else: | |
33 raise Exception('Type compare not implemented') | |
226 | 34 return False |
150 | 35 |
222 | 36 def canCast(fromT, toT): |
230 | 37 fromT = resolveType(fromT) |
38 toT = resolveType(toT) | |
222 | 39 if isinstance(fromT, PointerType) and isinstance(toT, PointerType): |
40 return True | |
41 elif fromT is intType and isinstance(toT, PointerType): | |
42 return True | |
43 return False | |
44 | |
230 | 45 def expectRval(s): |
46 # TODO: solve this better | |
47 s.expect_rvalue = True | |
48 | |
150 | 49 class TypeChecker: |
220
3f6c30a5d234
Major change in expression parsing to enable pointers and structs
Windel Bouwman
parents:
215
diff
changeset
|
50 def __init__(self, diag): |
3f6c30a5d234
Major change in expression parsing to enable pointers and structs
Windel Bouwman
parents:
215
diff
changeset
|
51 self.diag = diag |
3f6c30a5d234
Major change in expression parsing to enable pointers and structs
Windel Bouwman
parents:
215
diff
changeset
|
52 |
3f6c30a5d234
Major change in expression parsing to enable pointers and structs
Windel Bouwman
parents:
215
diff
changeset
|
53 def error(self, msg, loc): |
230 | 54 """ |
55 Wrapper that registers the message and marks the result invalid | |
228 | 56 """ |
186 | 57 self.diag.error(msg, loc) |
58 self.ok = False | |
220
3f6c30a5d234
Major change in expression parsing to enable pointers and structs
Windel Bouwman
parents:
215
diff
changeset
|
59 |
3f6c30a5d234
Major change in expression parsing to enable pointers and structs
Windel Bouwman
parents:
215
diff
changeset
|
60 def checkPackage(self, pkg): |
186 | 61 self.ok = True |
215 | 62 visitor = Visitor() |
63 visitor.visit(pkg, f_post=self.check2) | |
186 | 64 return self.ok |
220
3f6c30a5d234
Major change in expression parsing to enable pointers and structs
Windel Bouwman
parents:
215
diff
changeset
|
65 |
3f6c30a5d234
Major change in expression parsing to enable pointers and structs
Windel Bouwman
parents:
215
diff
changeset
|
66 def check2(self, sym): |
225 | 67 if type(sym) in [IfStatement, WhileStatement]: |
68 if not equalTypes(sym.condition.typ, boolType): | |
230 | 69 msg = 'Condition must be of type {}'.format(boolType) |
70 self.error(msg, sym.condition.loc) | |
225 | 71 elif type(sym) is Assignment: |
230 | 72 l, r = sym.lval, sym.rval |
73 if not equalTypes(l.typ, r.typ): | |
74 msg = 'Cannot assign {} to {}'.format(r.typ, l.typ) | |
75 self.error(msg, sym.loc) | |
76 if not l.lvalue: | |
77 self.error('No valid lvalue {}'.format(l), l.loc) | |
221 | 78 #if sym.rval.lvalue: |
79 # self.error('Right hand side must be an rvalue', sym.rval.loc) | |
230 | 80 expectRval(sym.rval) |
225 | 81 elif type(sym) is ReturnStatement: |
82 pass | |
83 elif type(sym) is FunctionCall: | |
167 | 84 # Check arguments: |
85 ngiv = len(sym.args) | |
86 ptypes = sym.proc.typ.parametertypes | |
87 nreq = len(ptypes) | |
88 if ngiv != nreq: | |
186 | 89 self.error('Function {2}: {0} arguments required, {1} given'.format(nreq, ngiv, sym.proc.name), sym.loc) |
167 | 90 else: |
91 for a, at in zip(sym.args, ptypes): | |
230 | 92 expectRval(a) |
167 | 93 if not equalTypes(a.typ, at): |
186 | 94 self.error('Got {0}, expected {1}'.format(a.typ, at), a.loc) |
167 | 95 # determine return type: |
96 sym.typ = sym.proc.typ.returntype | |
225 | 97 elif type(sym) is VariableUse: |
221 | 98 sym.lvalue = True |
225 | 99 if type(sym.target) is Variable: |
221 | 100 sym.typ = sym.target.typ |
101 else: | |
225 | 102 print('warning {} has no target, defaulting to int'.format(sym)) |
221 | 103 sym.typ = intType |
225 | 104 elif type(sym) is Literal: |
221 | 105 sym.lvalue = False |
106 if type(sym.val) is int: | |
107 sym.typ = intType | |
108 elif type(sym.val) is float: | |
109 sym.typ = doubleType | |
110 elif type(sym.val) is bool: | |
111 sym.typ = boolType | |
112 else: | |
225 | 113 raise Exception('Unknown literal type'.format(sym.val)) |
114 elif type(sym) is Unop: | |
220
3f6c30a5d234
Major change in expression parsing to enable pointers and structs
Windel Bouwman
parents:
215
diff
changeset
|
115 if sym.op == '&': |
3f6c30a5d234
Major change in expression parsing to enable pointers and structs
Windel Bouwman
parents:
215
diff
changeset
|
116 sym.typ = PointerType(sym.a.typ) |
221 | 117 sym.lvalue = False |
225 | 118 else: |
119 raise Exception('Unknown unop {0}'.format(sym.op)) | |
120 elif type(sym) is Deref: | |
121 # pointer deref | |
122 sym.lvalue = True | |
123 # check if the to be dereferenced variable is a pointer type: | |
230 | 124 ptype = resolveType(sym.ptr.typ) |
226 | 125 if type(ptype) is PointerType: |
126 sym.typ = ptype.ptype | |
225 | 127 else: |
226 | 128 self.error('Cannot dereference non-pointer type {}'.format(ptype), sym.loc) |
225 | 129 sym.typ = intType |
130 elif type(sym) is FieldRef: | |
131 basetype = sym.base.typ | |
230 | 132 sym.lvalue = sym.base.lvalue |
133 basetype = resolveType(basetype) | |
225 | 134 if type(basetype) is StructureType: |
135 if basetype.hasField(sym.field): | |
136 sym.typ = basetype.fieldType(sym.field) | |
220
3f6c30a5d234
Major change in expression parsing to enable pointers and structs
Windel Bouwman
parents:
215
diff
changeset
|
137 else: |
226 | 138 self.error('{} does not contain field {}'.format(basetype, sym.field), sym.loc) |
221 | 139 sym.typ = intType |
220
3f6c30a5d234
Major change in expression parsing to enable pointers and structs
Windel Bouwman
parents:
215
diff
changeset
|
140 else: |
225 | 141 self.error('Cannot select field {} of non-structure type {}'.format(sym.field, basetype), sym.loc) |
142 sym.typ = intType | |
143 elif type(sym) is Binop: | |
227 | 144 sym.lvalue = False |
145 if sym.op in ['+', '-', '*', '/']: | |
230 | 146 expectRval(sym.a) |
147 expectRval(sym.b) | |
227 | 148 if equalTypes(sym.a.typ, sym.b.typ): |
149 if equalTypes(sym.a.typ, intType): | |
150 sym.typ = sym.a.typ | |
151 else: | |
152 self.error('Can only add integers', sym.loc) | |
153 sym.typ = intType | |
154 else: | |
155 # assume void here? TODO: throw exception! | |
156 sym.typ = intType | |
157 self.error('Types unequal {} != {}'.format(sym.a.typ, sym.b.typ), sym.loc) | |
158 elif sym.op in ['>', '<', '==', '<=', '>=']: | |
159 sym.typ = boolType | |
160 if not equalTypes(sym.a.typ, sym.b.typ): | |
161 self.error('Types unequal {} != {}'.format(sym.a.typ, sym.b.typ), sym.loc) | |
162 elif sym.op in ['or', 'and']: | |
163 sym.typ = boolType | |
164 if not equalTypes(sym.a.typ, boolType): | |
165 self.error('Must be {0}'.format(boolType), sym.a.loc) | |
166 if not equalTypes(sym.b.typ, boolType): | |
167 self.error('Must be {0}'.format(boolType), sym.b.loc) | |
168 elif sym.op in ['|', '&']: | |
169 sym.typ = intType | |
170 sym.lvalue = False | |
171 if equalTypes(sym.a.typ, sym.b.typ): | |
172 if not equalTypes(sym.a.typ, intType): | |
173 self.error('Can only add integers', sym.loc) | |
174 else: | |
175 self.error('Types unequal {} != {}'.format(sym.a.typ, sym.b.typ), sym.loc) | |
163 | 176 else: |
227 | 177 raise Exception('Unknown binop {0}'.format(sym.op)) |
225 | 178 elif type(sym) is Variable: |
165 | 179 # check initial value type: |
180 # TODO | |
181 pass | |
225 | 182 elif type(sym) is TypeCast: |
222 | 183 if canCast(sym.a.typ, sym.to_type): |
184 sym.typ = sym.to_type | |
185 else: | |
230 | 186 self.error('Cannot cast {} to {}'.format(sym.a.typ, sym.to_type), sym.loc) |
187 sym.typ = intType | |
225 | 188 elif type(sym) is Constant: |
189 if not equalTypes(sym.typ, sym.value.typ): | |
190 self.error('Cannot assign {0} to {1}'.format(sym.value.typ, sym.typ), sym.loc) | |
228 | 191 elif type(sym) in [CompoundStatement, Package, Function, FunctionType, ExpressionStatement, DefinedType]: |
230 | 192 pass |
225 | 193 else: |
186 | 194 raise Exception('Unknown type check {0}'.format(sym)) |
150 | 195 |