+/TECS

git clone https://git.julia.blue/+/TECS

P1n3appl3Add break statementd69793d

master
11.2 KiB321 linesraw
1import sys
2from symboltable import SymbolTable
3from tokenizer import Tokenizer
4from vmwriter import VMWriter
5
6
7class CompilationEngine:
8
9    def __init__(self, fileName):
10        if '-x' in sys.argv:
11            self.writer = open(fileName.split('.')[0] + ".xml", 'w')
12        self.t = Tokenizer(fileName)
13        self.t.advance()
14        self.vm = VMWriter(fileName)
15        self.table = None
16        self.classTable = SymbolTable()
17        self.fieldCount = 0
18        self.currentWhile = []
19
20    def writeXML(self, s):
21        if '-x' in sys.argv:
22            self.writer.write(s + '\n')
23
24    def writeToken(self, n=1):
25        for i in range(n):
26            tempType = '<' + self.t.tokenType + '>'
27            tempToken = self.t.token.replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;').replace('"', '&quot;')
28            self.writeXML('<' + self.t.tokenType + '> ' + tempToken + ' </' + self.t.tokenType + '>')
29            self.t.advance()
30
31    def compileClass(self):
32        self.writeXML("<class>")
33        self.writeToken()
34        self.className = self.t.token
35        self.writeToken(2)
36        while self.t.token in ("static", "field"):
37            self.compileClassVarDec()
38        while self.t.token != '}':
39            self.compileSubroutine()
40        self.writeToken()
41        self.writeXML("</class>")
42
43    def compileClassVarDec(self):
44        self.writeXML("<classVarDec>")
45        kind = self.t.token
46        self.writeToken()
47        type = self.t.token
48        self.writeToken()
49        while self.t.token != ';':
50            if self.t.token != ',':
51                self.classTable.add(self.t.token, type, kind)
52                if kind == "field":
53                    self.fieldCount += 1
54            self.writeToken()
55        self.writeToken()
56        self.writeXML("</classVarDec>")
57
58    def compileSubroutine(self):
59        self.writeXML("<subroutineDec>")
60        self.whileCount = 0
61        self.ifCount = 0
62        self.table = SymbolTable()
63        self.functionKind = self.t.token
64        self.writeToken()
65        self.functionType = self.t.token
66        self.writeToken()
67        functionName = self.t.token
68        self.writeToken(2)
69        self.compileParameterList()
70        self.writeToken()
71        self.writeXML("<subroutineBody>")
72        self.writeToken()
73        while self.t.token == "var":
74            self.compileVarDec()
75        varNum = len([i for i in self.table.table if self.table.getKind(i) == "local"])
76        self.vm.writeFunction(self.className + '.' + functionName, varNum)
77        if self.functionKind == "constructor":
78            self.vm.writePush("constant", self.fieldCount)
79            self.vm.writeCall("Memory.alloc", 1)
80            self.vm.writePop("pointer", 0)
81        elif self.functionKind == "method":
82            self.vm.writePush("argument", 0)
83            self.vm.writePop("pointer", 0)
84        self.compileStatements()
85        self.writeToken()
86        self.writeXML("</subroutineBody>")
87        self.writeXML("</subroutineDec>")
88
89    def compileParameterList(self):
90        self.writeXML("<parameterList>")
91        if self.functionKind == "method":   # add empty argument for self
92            self.table.add('', self.className, "argument")
93        while self.t.token != ')':
94            type = self.t.token
95            self.writeToken()
96            self.table.add(self.t.token, type, "argument")
97            self.writeToken()
98            if self.t.token == ',':
99                self.writeToken()
100        self.writeXML("</parameterList>")
101
102    def compileVarDec(self):
103        self.writeXML("<varDec>")
104        self.writeToken()
105        type = self.t.token
106        self.writeToken()
107        while self.t.token != ';':
108            if self.t.token != ',':
109                self.table.add(self.t.token, type, "local")
110            self.writeToken()
111        self.writeToken()
112        self.writeXML("</varDec>")
113
114    def compileStatements(self):
115        self.writeXML("<statements>")
116        while self.t.token != '}':
117            if self.t.token == 'let':
118                self.compileLet()
119            elif self.t.token == 'do':
120                self.compileDo()
121            elif self.t.token == 'if':
122                self.compileIf()
123            elif self.t.token == 'while':
124                self.compileWhile()
125            elif self.t.token == 'return':
126                self.compileReturn()
127            elif self.t.token == 'break':
128                self.compileReturn()
129        self.writeXML("</statements>")
130
131    def compileDo(self):
132        self.writeXML("<doStatement>")
133        self.writeToken()
134        name = self.t.token
135        self.writeToken()
136        self.compileCall(name)
137        self.vm.writePop("temp", 0)
138        self.writeToken()
139        self.writeXML("</doStatement>")
140
141    def compileBreak(self):
142        self.writeXML("<breakStatement>")
143        self.vm.writeGoto("WHILE_END" + str(self.currentWhile[-1]))
144        self.writeToken(2)
145        self.writeXML("</breakStatement>")
146
147    def compileLet(self):
148        self.writeXML("<letStatement>")
149        self.writeToken()
150        name = self.t.token
151        self.writeToken()
152        temp = False
153        if self.t.token == '[':
154            self.compileArray(name)
155            temp = True
156        self.writeToken()
157        self.compileExpression()
158        self.writeToken()
159        t = self.table
160        if not t.has(name):
161            t = self.classTable
162        if temp:
163            self.vm.writePop("temp", 0)
164            self.vm.writePop("pointer", 1)
165            self.vm.writePush("temp", 0)
166            self.vm.writePop("that", 0)
167        else:
168            self.vm.writePop(t.getKind(name), t.getCount(name))
169        self.writeXML("</letStatement>")
170
171    def compileWhile(self):
172        self.currentWhile.append(self.whileCount)
173        self.whileCount += 1
174        self.writeXML("<whileStatement>")
175        self.writeToken(2)
176        self.vm.writeLabel("WHILE_EXP" + str(self.currentWhile[-1]))
177        self.compileExpression()
178        self.vm.writeUnary('~')
179        self.vm.writeIf("WHILE_END" + str(self.currentWhile[-1]))
180        self.writeToken(2)
181        self.compileStatements()
182        self.vm.writeGoto("WHILE_EXP" + str(self.currentWhile[-1]))
183        self.writeToken()
184        self.vm.writeLabel("WHILE_END" + str(self.currentWhile[-1]))
185        del(self.currentWhile[-1])
186        self.writeXML("</whileStatement>")
187
188    def compileIf(self):
189        currentCount = self.ifCount
190        self.ifCount += 1
191        self.writeXML("<ifStatement>")
192        self.writeToken(2)
193        self.compileExpression()
194        self.vm.writeIf("IF_TRUE" + str(currentCount))
195        self.vm.writeGoto("IF_FALSE" + str(currentCount))
196        self.vm.writeLabel("IF_TRUE" + str(currentCount))
197        self.writeToken(2)
198        self.compileStatements()
199        self.writeToken()
200        if self.t.token == "else":
201            self.vm.writeGoto("IF_END" + str(currentCount))
202            self.vm.writeLabel("IF_FALSE" + str(currentCount))
203            self.writeToken(2)
204            self.compileStatements()
205            self.writeToken()
206            self.vm.writeLabel("IF_END" + str(currentCount))
207        else:
208            self.vm.writeLabel("IF_FALSE" + str(currentCount))
209        self.writeXML("</ifStatement>")
210
211    def compileReturn(self):
212        self.writeXML("<returnStatement>")
213        self.writeToken()
214        if self.t.token != ';':
215            self.compileExpression()
216        self.writeToken()
217        if self.functionType == "void":
218            self.vm.writePush("constant", 0)
219        self.vm.writeReturn()
220        self.writeXML("</returnStatement>")
221
222    def compileCall(self, name):    # starts with tokenizer after the function name
223        argNum = 0
224        if self.t.token == '.':  # not a local method
225            self.writeToken()
226            t = self.table
227            if not t.has(name):  # not a local object's method
228                t = self.classTable
229            if t.has(name):  # must be a local or field object's method
230                self.vm.writePush(t.getKind(name), t.getCount(name))
231                name = t.getType(name) + '.' + self.t.token
232                argNum = 1
233            else:   # must be an external function
234                name += '.' + self.t.token
235            self.writeToken()
236        else:   # local method
237            self.vm.writePush("pointer", 0)
238            name = self.className + '.' + name
239            argNum = 1
240        self.writeToken()
241        argNum += self.compileExpressionList()
242        self.writeToken()
243        self.vm.writeCall(name, argNum)
244
245    def compileArray(self, name):   # starts with tokenizer after the array name
246        t = self.table
247        if not t.has(name):
248            t = self.classTable
249        self.writeToken()
250        self.compileExpression()
251        self.writeToken()
252        self.vm.writePush(t.getKind(name), t.getCount(name))
253        self.vm.writeArithmetic('+')
254
255    def compileExpressionList(self):
256        self.writeXML("<expressionList>")
257        n = 0
258        if self.t.token != ')':
259            self.compileExpression()
260            n = 1
261        while self.t.token == ',':
262            n += 1
263            self.writeToken()
264            self.compileExpression()
265        self.writeXML("</expressionList>")
266        return n
267
268    def compileExpression(self):
269        self.writeXML("<expression>")
270        self.compileTerm()
271        while self.t.token in "+-*/%&|~=<=>==":
272            op = self.t.token
273            self.writeToken()
274            self.compileTerm()
275            self.vm.writeArithmetic(op)
276        self.writeXML("</expression>")
277
278    def compileTerm(self):
279        self.writeXML("<term>")
280        if self.t.tokenType == "stringConstant":
281            self.vm.writePush("constant", len(self.t.token))
282            self.vm.writeCall("String.new", 1)
283            for i in self.t.token:
284                self.vm.writePush("constant", ord(i))
285                self.vm.writeCall("String.appendChar", 2)
286            self.writeToken()
287        elif self.t.token in "~-" and self.t.token != '':
288            op = self.t.token
289            self.writeToken()
290            self.compileTerm()
291            self.vm.writeUnary(op)
292        elif self.t.token == '(':
293            self.writeToken()
294            self.compileExpression()
295            self.writeToken()
296        elif self.t.tokenType == "identifier":
297            name = self.t.token
298            self.writeToken()
299            if self.t.token == '[':  # array
300                self.compileArray(name)
301                self.vm.writePop("pointer", 1)
302                self.vm.writePush("that", 0)
303            elif self.t.token in "(.":  # function
304                self.compileCall(name)
305            else:   # normal variable/object
306                t = self.table
307                if not t.has(name):
308                    t = self.classTable
309                self.vm.writePush(t.getKind(name), t.getCount(name))
310        else:
311            if self.t.tokenType == "integerConstant":
312                self.vm.writePush("constant", self.t.token)
313            elif self.t.tokenType == "keyword":  # this/null/false/true
314                if self.t.token == "this":
315                    self.vm.writePush("pointer", 0)
316                else:
317                    self.vm.writePush("constant", 0)
318                    if self.t.token == "true":
319                        self.vm.writeUnary('~')
320            self.writeToken()
321        self.writeXML("</term>")