Mercurial > hg > graal-compiler
comparison graal/com.oracle.truffle.sl/src/com/oracle/truffle/sl/parser/Parser.java @ 13821:b16ec83edc73
Documentation and more refactoring of Simple Language
author | Christian Wimmer <christian.wimmer@oracle.com> |
---|---|
date | Wed, 29 Jan 2014 20:45:43 -0800 |
parents | cad8bed1a1ac |
children | 64c77f0577bb |
comparison
equal
deleted
inserted
replaced
13820:20e7727588e8 | 13821:b16ec83edc73 |
---|---|
1 /* | 1 /* |
2 * Copyright (c) 2012, 2012, Oracle and/or its affiliates. All rights reserved. | 2 * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved. |
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 * | 4 * |
5 * This code is free software; you can redistribute it and/or modify it | 5 * This code is free software; you can redistribute it and/or modify it |
6 * under the terms of the GNU General Public License version 2 only, as | 6 * under the terms of the GNU General Public License version 2 only, as |
7 * published by the Free Software Foundation. | 7 * published by the Free Software Foundation. |
53 public final Errors errors; | 53 public final Errors errors; |
54 private final SLNodeFactory factory; | 54 private final SLNodeFactory factory; |
55 | 55 |
56 public Parser(SLContext context, Source source) { | 56 public Parser(SLContext context, Source source) { |
57 this.scanner = new Scanner(source.getInputStream()); | 57 this.scanner = new Scanner(source.getInputStream()); |
58 this.factory = new SLNodeFactory(context, source, this); | 58 this.factory = new SLNodeFactory(context, source); |
59 errors = new Errors(); | 59 errors = new Errors(); |
60 } | 60 } |
61 | 61 |
62 void SynErr(int n) { | 62 void SynErr(int n) { |
63 if (errDist >= minErrDist) | 63 if (errDist >= minErrDist) |
131 } | 131 } |
132 | 132 |
133 void Function() { | 133 void Function() { |
134 Expect(4); | 134 Expect(4); |
135 Expect(1); | 135 Expect(1); |
136 String name = t.val; | 136 factory.startFunction(t); |
137 Expect(5); | 137 Expect(5); |
138 List<String> parameters = new ArrayList<>(); | |
139 if (la.kind == 1) { | 138 if (la.kind == 1) { |
140 Get(); | 139 Get(); |
141 parameters.add(t.val); | 140 factory.addFormalParameter(t); |
142 while (la.kind == 6) { | 141 while (la.kind == 6) { |
143 Get(); | 142 Get(); |
144 Expect(1); | 143 Expect(1); |
145 parameters.add(t.val); | 144 factory.addFormalParameter(t); |
146 } | 145 } |
147 } | 146 } |
148 Expect(7); | 147 Expect(7); |
149 factory.startFunction(name, parameters); | |
150 SLStatementNode body = Block(); | 148 SLStatementNode body = Block(); |
151 factory.finishFunction(body); | 149 factory.finishFunction(body); |
152 } | 150 } |
153 | 151 |
154 SLStatementNode Block() { | 152 SLStatementNode Block() { |
155 SLStatementNode result; | 153 SLStatementNode result; |
156 factory.startBlock(); | 154 factory.startBlock(); |
157 List<SLStatementNode> statements = new ArrayList<>(); | 155 List<SLStatementNode> body = new ArrayList<>(); |
158 Expect(8); | 156 Expect(8); |
159 while (StartOf(1)) { | 157 while (StartOf(1)) { |
160 SLStatementNode statement = Statement(); | 158 SLStatementNode s = Statement(); |
161 statements.add(statement); | 159 body.add(s); |
162 } | 160 } |
163 Expect(9); | 161 Expect(9); |
164 result = factory.finishBlock(statements); | 162 result = factory.finishBlock(body); |
165 return result; | 163 return result; |
166 } | 164 } |
167 | 165 |
168 SLStatementNode Statement() { | 166 SLStatementNode Statement() { |
169 SLStatementNode result; | 167 SLStatementNode result; |
170 result = null; | 168 result = null; |
171 switch (la.kind) { | 169 switch (la.kind) { |
172 case 15: { | 170 case 13: { |
173 result = WhileStatement(); | 171 result = WhileStatement(); |
174 break; | 172 break; |
175 } | 173 } |
176 case 10: { | 174 case 10: { |
177 Get(); | 175 Get(); |
178 result = factory.createBreak(); | 176 result = factory.createBreak(t); |
179 Expect(11); | 177 Expect(11); |
180 break; | 178 break; |
181 } | 179 } |
182 case 12: { | 180 case 12: { |
183 Get(); | 181 Get(); |
184 result = factory.createContinue(); | 182 result = factory.createContinue(t); |
185 Expect(11); | 183 Expect(11); |
186 break; | 184 break; |
187 } | 185 } |
188 case 13: { | 186 case 14: { |
189 result = IfStatement(); | 187 result = IfStatement(); |
190 break; | 188 break; |
191 } | 189 } |
192 case 16: { | 190 case 16: { |
193 result = ReturnStatement(); | 191 result = ReturnStatement(); |
203 return result; | 201 return result; |
204 } | 202 } |
205 | 203 |
206 SLStatementNode WhileStatement() { | 204 SLStatementNode WhileStatement() { |
207 SLStatementNode result; | 205 SLStatementNode result; |
208 Expect(15); | 206 Expect(13); |
209 Expect(5); | 207 Expect(5); |
208 Token whileToken = t; | |
210 SLExpressionNode condition = Expression(); | 209 SLExpressionNode condition = Expression(); |
211 Expect(7); | 210 Expect(7); |
212 SLStatementNode body = Block(); | 211 SLStatementNode body = Block(); |
213 result = factory.createWhile(condition, body); | 212 result = factory.createWhile(whileToken, condition, body); |
214 return result; | 213 return result; |
215 } | 214 } |
216 | 215 |
217 SLStatementNode IfStatement() { | 216 SLStatementNode IfStatement() { |
218 SLStatementNode result; | 217 SLStatementNode result; |
219 Expect(13); | 218 Expect(14); |
220 Expect(5); | 219 Expect(5); |
220 Token ifToken = t; | |
221 SLExpressionNode condition = Expression(); | 221 SLExpressionNode condition = Expression(); |
222 Expect(7); | 222 Expect(7); |
223 SLStatementNode thenPart = Block(); | 223 SLStatementNode thenPart = Block(); |
224 SLStatementNode elsePart = null; | 224 SLStatementNode elsePart = null; |
225 if (la.kind == 14) { | 225 if (la.kind == 15) { |
226 Get(); | 226 Get(); |
227 elsePart = Block(); | 227 elsePart = Block(); |
228 } | 228 } |
229 result = factory.createIf(condition, thenPart, elsePart); | 229 result = factory.createIf(ifToken, condition, thenPart, elsePart); |
230 return result; | 230 return result; |
231 } | 231 } |
232 | 232 |
233 SLStatementNode ReturnStatement() { | 233 SLStatementNode ReturnStatement() { |
234 SLStatementNode result; | 234 SLStatementNode result; |
235 Expect(16); | 235 Expect(16); |
236 SLExpressionNode value = Expression(); | 236 Token returnToken = t; |
237 SLExpressionNode value = null; | |
238 if (StartOf(2)) { | |
239 value = Expression(); | |
240 } | |
241 result = factory.createReturn(returnToken, value); | |
237 Expect(11); | 242 Expect(11); |
238 result = factory.createReturn(value); | |
239 return result; | 243 return result; |
240 } | 244 } |
241 | 245 |
242 SLExpressionNode Expression() { | 246 SLExpressionNode Expression() { |
243 SLExpressionNode result; | 247 SLExpressionNode result; |
244 result = LogicTerm(); | 248 result = LogicTerm(); |
245 while (la.kind == 17) { | 249 while (la.kind == 17) { |
246 Get(); | 250 Get(); |
247 String op = t.val; | 251 Token op = t; |
248 SLExpressionNode right = LogicTerm(); | 252 SLExpressionNode right = LogicTerm(); |
249 result = factory.createBinary(op, result, right); | 253 result = factory.createBinary(op, result, right); |
250 } | 254 } |
251 return result; | 255 return result; |
252 } | 256 } |
254 SLExpressionNode LogicTerm() { | 258 SLExpressionNode LogicTerm() { |
255 SLExpressionNode result; | 259 SLExpressionNode result; |
256 result = LogicFactor(); | 260 result = LogicFactor(); |
257 while (la.kind == 18) { | 261 while (la.kind == 18) { |
258 Get(); | 262 Get(); |
259 String op = t.val; | 263 Token op = t; |
260 SLExpressionNode right = LogicFactor(); | 264 SLExpressionNode right = LogicFactor(); |
261 result = factory.createBinary(op, result, right); | 265 result = factory.createBinary(op, result, right); |
262 } | 266 } |
263 return result; | 267 return result; |
264 } | 268 } |
265 | 269 |
266 SLExpressionNode LogicFactor() { | 270 SLExpressionNode LogicFactor() { |
267 SLExpressionNode result; | 271 SLExpressionNode result; |
268 result = Arithmetic(); | 272 result = Arithmetic(); |
269 if (StartOf(2)) { | 273 if (StartOf(3)) { |
270 switch (la.kind) { | 274 switch (la.kind) { |
271 case 19: { | 275 case 19: { |
272 Get(); | 276 Get(); |
273 break; | 277 break; |
274 } | 278 } |
291 case 24: { | 295 case 24: { |
292 Get(); | 296 Get(); |
293 break; | 297 break; |
294 } | 298 } |
295 } | 299 } |
296 String op = t.val; | 300 Token op = t; |
297 SLExpressionNode right = Arithmetic(); | 301 SLExpressionNode right = Arithmetic(); |
298 result = factory.createBinary(op, result, right); | 302 result = factory.createBinary(op, result, right); |
299 } | 303 } |
300 return result; | 304 return result; |
301 } | 305 } |
307 if (la.kind == 25) { | 311 if (la.kind == 25) { |
308 Get(); | 312 Get(); |
309 } else { | 313 } else { |
310 Get(); | 314 Get(); |
311 } | 315 } |
312 String op = t.val; | 316 Token op = t; |
313 SLExpressionNode right = Term(); | 317 SLExpressionNode right = Term(); |
314 result = factory.createBinary(op, result, right); | 318 result = factory.createBinary(op, result, right); |
315 } | 319 } |
316 return result; | 320 return result; |
317 } | 321 } |
323 if (la.kind == 27) { | 327 if (la.kind == 27) { |
324 Get(); | 328 Get(); |
325 } else { | 329 } else { |
326 Get(); | 330 Get(); |
327 } | 331 } |
328 String op = t.val; | 332 Token op = t; |
329 SLExpressionNode right = Factor(); | 333 SLExpressionNode right = Factor(); |
330 result = factory.createBinary(op, result, right); | 334 result = factory.createBinary(op, result, right); |
331 } | 335 } |
332 return result; | 336 return result; |
333 } | 337 } |
335 SLExpressionNode Factor() { | 339 SLExpressionNode Factor() { |
336 SLExpressionNode result; | 340 SLExpressionNode result; |
337 result = null; | 341 result = null; |
338 if (la.kind == 1) { | 342 if (la.kind == 1) { |
339 Get(); | 343 Get(); |
340 String name = t.val; | 344 Token nameToken = t; |
341 if (la.kind == 5) { | 345 if (la.kind == 5) { |
342 Get(); | 346 Get(); |
343 List<SLExpressionNode> parameters = new ArrayList<>(); | 347 List<SLExpressionNode> parameters = new ArrayList<>(); |
344 SLExpressionNode parameter; | 348 SLExpressionNode parameter; |
345 if (StartOf(3)) { | 349 if (StartOf(2)) { |
346 parameter = Expression(); | 350 parameter = Expression(); |
347 parameters.add(parameter); | 351 parameters.add(parameter); |
348 while (la.kind == 6) { | 352 while (la.kind == 6) { |
349 Get(); | 353 Get(); |
350 parameter = Expression(); | 354 parameter = Expression(); |
351 parameters.add(parameter); | 355 parameters.add(parameter); |
352 } | 356 } |
353 } | 357 } |
354 result = factory.createCall(factory.createRead(name), parameters); | 358 result = factory.createCall(nameToken, parameters); |
355 Expect(7); | 359 Expect(7); |
356 } else if (la.kind == 29) { | 360 } else if (la.kind == 29) { |
357 Get(); | 361 Get(); |
358 SLExpressionNode value = Expression(); | 362 SLExpressionNode value = Expression(); |
359 result = factory.createAssignment(name, value); | 363 result = factory.createAssignment(nameToken, value); |
360 } else if (StartOf(4)) { | 364 } else if (StartOf(4)) { |
361 result = factory.createRead(name); | 365 result = factory.createRead(nameToken); |
362 } else SynErr(32); | 366 } else SynErr(32); |
363 } else if (la.kind == 2) { | 367 } else if (la.kind == 2) { |
364 Get(); | 368 Get(); |
365 result = factory.createStringLiteral(t.val.substring(1, t.val.length() - 1)); | 369 result = factory.createStringLiteral(t); |
366 } else if (la.kind == 3) { | 370 } else if (la.kind == 3) { |
367 Get(); | 371 Get(); |
368 result = factory.createNumericLiteral(t.val); | 372 result = factory.createNumericLiteral(t); |
369 } else if (la.kind == 5) { | 373 } else if (la.kind == 5) { |
370 Get(); | 374 Get(); |
371 result = Expression(); | 375 result = Expression(); |
372 Expect(7); | 376 Expect(7); |
373 } else SynErr(33); | 377 } else SynErr(33); |
385 | 389 |
386 } | 390 } |
387 | 391 |
388 private static final boolean[][] set = { | 392 private static final boolean[][] set = { |
389 {T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x}, | 393 {T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x}, |
390 {x,T,T,T, x,T,x,x, x,x,T,x, T,T,x,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x}, | 394 {x,T,T,T, x,T,x,x, x,x,T,x, T,T,T,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x}, |
395 {x,T,T,T, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x}, | |
391 {x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,T,T,T, T,x,x,x, x,x,x,x}, | 396 {x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,T,T,T, T,x,x,x, x,x,x,x}, |
392 {x,T,T,T, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x}, | |
393 {x,x,x,x, x,x,T,T, x,x,x,T, x,x,x,x, x,T,T,T, T,T,T,T, T,T,T,T, T,x,x,x} | 397 {x,x,x,x, x,x,T,T, x,x,x,T, x,x,x,x, x,T,T,T, T,T,T,T, T,T,T,T, T,x,x,x} |
394 | 398 |
395 }; | 399 }; |
396 | 400 |
397 public static void parseSL(SLContext context, Source source) { | 401 public static void parseSL(SLContext context, Source source) { |
444 case 8: s = "\"{\" expected"; break; | 448 case 8: s = "\"{\" expected"; break; |
445 case 9: s = "\"}\" expected"; break; | 449 case 9: s = "\"}\" expected"; break; |
446 case 10: s = "\"break\" expected"; break; | 450 case 10: s = "\"break\" expected"; break; |
447 case 11: s = "\";\" expected"; break; | 451 case 11: s = "\";\" expected"; break; |
448 case 12: s = "\"continue\" expected"; break; | 452 case 12: s = "\"continue\" expected"; break; |
449 case 13: s = "\"if\" expected"; break; | 453 case 13: s = "\"while\" expected"; break; |
450 case 14: s = "\"else\" expected"; break; | 454 case 14: s = "\"if\" expected"; break; |
451 case 15: s = "\"while\" expected"; break; | 455 case 15: s = "\"else\" expected"; break; |
452 case 16: s = "\"return\" expected"; break; | 456 case 16: s = "\"return\" expected"; break; |
453 case 17: s = "\"||\" expected"; break; | 457 case 17: s = "\"||\" expected"; break; |
454 case 18: s = "\"&&\" expected"; break; | 458 case 18: s = "\"&&\" expected"; break; |
455 case 19: s = "\"<\" expected"; break; | 459 case 19: s = "\"<\" expected"; break; |
456 case 20: s = "\">\" expected"; break; | 460 case 20: s = "\"<=\" expected"; break; |
457 case 21: s = "\"<=\" expected"; break; | 461 case 21: s = "\">\" expected"; break; |
458 case 22: s = "\">=\" expected"; break; | 462 case 22: s = "\">=\" expected"; break; |
459 case 23: s = "\"==\" expected"; break; | 463 case 23: s = "\"==\" expected"; break; |
460 case 24: s = "\"!=\" expected"; break; | 464 case 24: s = "\"!=\" expected"; break; |
461 case 25: s = "\"+\" expected"; break; | 465 case 25: s = "\"+\" expected"; break; |
462 case 26: s = "\"-\" expected"; break; | 466 case 26: s = "\"-\" expected"; break; |