+/TECS

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

P1n3appl3Fix string constant parsing bug5d03072

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