Mercurial > hg > graal-compiler
comparison graal/com.oracle.truffle.sl/src/com/oracle/truffle/sl/parser/Parser.java @ 16067:915ebb306fcc
Truffle/Source: major API revision
- All source-related classes now in com.oracle.truffle.api.source
- SourceFactory replaced with factory methods on Source
- Revision, renaming, and documentation to methods on Source and SourceSection
- NullSourceSection is now a utility class
author | Michael Van De Vanter <michael.van.de.vanter@oracle.com> |
---|---|
date | Fri, 06 Jun 2014 17:51:47 -0700 |
parents | 64c77f0577bb |
children | abe7128ca473 |
comparison
equal
deleted
inserted
replaced
16066:f59498d6e8b1 | 16067:915ebb306fcc |
---|---|
25 | 25 |
26 package com.oracle.truffle.sl.parser; | 26 package com.oracle.truffle.sl.parser; |
27 | 27 |
28 import java.util.*; | 28 import java.util.*; |
29 | 29 |
30 import com.oracle.truffle.api.*; | 30 import com.oracle.truffle.api.source.*; |
31 import com.oracle.truffle.sl.*; | 31 import com.oracle.truffle.sl.*; |
32 import com.oracle.truffle.sl.nodes.*; | 32 import com.oracle.truffle.sl.nodes.*; |
33 import com.oracle.truffle.sl.runtime.*; | 33 import com.oracle.truffle.sl.runtime.*; |
34 | 34 |
35 // Checkstyle: stop | 35 // Checkstyle: stop |
50 int errDist = minErrDist; | 50 int errDist = minErrDist; |
51 | 51 |
52 public final Scanner scanner; | 52 public final Scanner scanner; |
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); | 58 this.factory = new SLNodeFactory(context, source); |
59 errors = new Errors(); | 59 errors = new Errors(); |
60 } | 60 } |
131 } | 131 } |
132 | 132 |
133 void Function() { | 133 void Function() { |
134 Expect(4); | 134 Expect(4); |
135 Expect(1); | 135 Expect(1); |
136 factory.startFunction(t); | 136 factory.startFunction(t); |
137 Expect(5); | 137 Expect(5); |
138 if (la.kind == 1) { | 138 if (la.kind == 1) { |
139 Get(); | 139 Get(); |
140 factory.addFormalParameter(t); | 140 factory.addFormalParameter(t); |
141 while (la.kind == 6) { | 141 while (la.kind == 6) { |
142 Get(); | 142 Get(); |
143 Expect(1); | 143 Expect(1); |
144 factory.addFormalParameter(t); | 144 factory.addFormalParameter(t); |
145 } | 145 } |
146 } | 146 } |
147 Expect(7); | 147 Expect(7); |
148 SLStatementNode body = Block(false); | 148 SLStatementNode body = Block(false); |
149 factory.finishFunction(body); | 149 factory.finishFunction(body); |
150 } | 150 } |
151 | 151 |
152 SLStatementNode Block(boolean inLoop) { | 152 SLStatementNode Block(boolean inLoop) { |
153 SLStatementNode result; | 153 SLStatementNode result; |
154 factory.startBlock(); | 154 factory.startBlock(); |
155 List<SLStatementNode> body = new ArrayList<>(); | 155 List<SLStatementNode> body = new ArrayList<>(); |
156 Expect(8); | 156 Expect(8); |
157 while (StartOf(1)) { | 157 while (StartOf(1)) { |
158 SLStatementNode s = Statement(inLoop); | 158 SLStatementNode s = Statement(inLoop); |
159 body.add(s); | 159 body.add(s); |
160 } | 160 } |
161 Expect(9); | 161 Expect(9); |
162 result = factory.finishBlock(body); | 162 result = factory.finishBlock(body); |
163 return result; | 163 return result; |
164 } | 164 } |
165 | 165 |
166 SLStatementNode Statement(boolean inLoop) { | 166 SLStatementNode Statement(boolean inLoop) { |
167 SLStatementNode result; | 167 SLStatementNode result; |
168 result = null; | 168 result = null; |
169 switch (la.kind) { | 169 switch (la.kind) { |
170 case 13: { | 170 case 13: { |
171 result = WhileStatement(); | 171 result = WhileStatement(); |
172 break; | 172 break; |
173 } | 173 } |
174 case 10: { | 174 case 10: { |
175 Get(); | 175 Get(); |
176 if (inLoop) { result = factory.createBreak(t); } else { SemErr("break used outside of loop"); } | 176 if (inLoop) { result = factory.createBreak(t); } else { SemErr("break used outside of loop"); } |
177 Expect(11); | 177 Expect(11); |
178 break; | 178 break; |
179 } | 179 } |
180 case 12: { | 180 case 12: { |
181 Get(); | 181 Get(); |
182 if (inLoop) { result = factory.createContinue(t); } else { SemErr("continue used outside of loop"); } | 182 if (inLoop) { result = factory.createContinue(t); } else { SemErr("continue used outside of loop"); } |
183 Expect(11); | 183 Expect(11); |
184 break; | 184 break; |
185 } | 185 } |
186 case 14: { | 186 case 14: { |
187 result = IfStatement(inLoop); | 187 result = IfStatement(inLoop); |
203 | 203 |
204 SLStatementNode WhileStatement() { | 204 SLStatementNode WhileStatement() { |
205 SLStatementNode result; | 205 SLStatementNode result; |
206 Expect(13); | 206 Expect(13); |
207 Expect(5); | 207 Expect(5); |
208 Token whileToken = t; | 208 Token whileToken = t; |
209 SLExpressionNode condition = Expression(); | 209 SLExpressionNode condition = Expression(); |
210 Expect(7); | 210 Expect(7); |
211 SLStatementNode body = Block(true); | 211 SLStatementNode body = Block(true); |
212 result = factory.createWhile(whileToken, condition, body); | 212 result = factory.createWhile(whileToken, condition, body); |
213 return result; | 213 return result; |
214 } | 214 } |
215 | 215 |
216 SLStatementNode IfStatement(boolean inLoop) { | 216 SLStatementNode IfStatement(boolean inLoop) { |
217 SLStatementNode result; | 217 SLStatementNode result; |
218 Expect(14); | 218 Expect(14); |
219 Expect(5); | 219 Expect(5); |
220 Token ifToken = t; | 220 Token ifToken = t; |
221 SLExpressionNode condition = Expression(); | 221 SLExpressionNode condition = Expression(); |
222 Expect(7); | 222 Expect(7); |
223 SLStatementNode thenPart = Block(inLoop); | 223 SLStatementNode thenPart = Block(inLoop); |
224 SLStatementNode elsePart = null; | 224 SLStatementNode elsePart = null; |
225 if (la.kind == 15) { | 225 if (la.kind == 15) { |
226 Get(); | 226 Get(); |
227 elsePart = Block(inLoop); | 227 elsePart = Block(inLoop); |
228 } | 228 } |
229 result = factory.createIf(ifToken, 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 Token returnToken = t; | 236 Token returnToken = t; |
237 SLExpressionNode value = null; | 237 SLExpressionNode value = null; |
238 if (StartOf(2)) { | 238 if (StartOf(2)) { |
239 value = Expression(); | 239 value = Expression(); |
240 } | 240 } |
241 result = factory.createReturn(returnToken, value); | 241 result = factory.createReturn(returnToken, value); |
242 Expect(11); | 242 Expect(11); |
243 return result; | 243 return result; |
244 } | 244 } |
245 | 245 |
246 SLExpressionNode Expression() { | 246 SLExpressionNode Expression() { |
247 SLExpressionNode result; | 247 SLExpressionNode result; |
248 result = LogicTerm(); | 248 result = LogicTerm(); |
249 while (la.kind == 17) { | 249 while (la.kind == 17) { |
250 Get(); | 250 Get(); |
251 Token op = t; | 251 Token op = t; |
252 SLExpressionNode right = LogicTerm(); | 252 SLExpressionNode right = LogicTerm(); |
253 result = factory.createBinary(op, result, right); | 253 result = factory.createBinary(op, result, right); |
254 } | 254 } |
255 return result; | 255 return result; |
256 } | 256 } |
257 | 257 |
258 SLExpressionNode LogicTerm() { | 258 SLExpressionNode LogicTerm() { |
259 SLExpressionNode result; | 259 SLExpressionNode result; |
260 result = LogicFactor(); | 260 result = LogicFactor(); |
261 while (la.kind == 18) { | 261 while (la.kind == 18) { |
262 Get(); | 262 Get(); |
263 Token op = t; | 263 Token op = t; |
264 SLExpressionNode right = LogicFactor(); | 264 SLExpressionNode right = LogicFactor(); |
265 result = factory.createBinary(op, result, right); | 265 result = factory.createBinary(op, result, right); |
266 } | 266 } |
267 return result; | 267 return result; |
268 } | 268 } |
269 | 269 |
270 SLExpressionNode LogicFactor() { | 270 SLExpressionNode LogicFactor() { |
295 case 24: { | 295 case 24: { |
296 Get(); | 296 Get(); |
297 break; | 297 break; |
298 } | 298 } |
299 } | 299 } |
300 Token op = t; | 300 Token op = t; |
301 SLExpressionNode right = Arithmetic(); | 301 SLExpressionNode right = Arithmetic(); |
302 result = factory.createBinary(op, result, right); | 302 result = factory.createBinary(op, result, right); |
303 } | 303 } |
304 return result; | 304 return result; |
305 } | 305 } |
306 | 306 |
307 SLExpressionNode Arithmetic() { | 307 SLExpressionNode Arithmetic() { |
311 if (la.kind == 25) { | 311 if (la.kind == 25) { |
312 Get(); | 312 Get(); |
313 } else { | 313 } else { |
314 Get(); | 314 Get(); |
315 } | 315 } |
316 Token op = t; | 316 Token op = t; |
317 SLExpressionNode right = Term(); | 317 SLExpressionNode right = Term(); |
318 result = factory.createBinary(op, result, right); | 318 result = factory.createBinary(op, result, right); |
319 } | 319 } |
320 return result; | 320 return result; |
321 } | 321 } |
322 | 322 |
323 SLExpressionNode Term() { | 323 SLExpressionNode Term() { |
327 if (la.kind == 27) { | 327 if (la.kind == 27) { |
328 Get(); | 328 Get(); |
329 } else { | 329 } else { |
330 Get(); | 330 Get(); |
331 } | 331 } |
332 Token op = t; | 332 Token op = t; |
333 SLExpressionNode right = Factor(); | 333 SLExpressionNode right = Factor(); |
334 result = factory.createBinary(op, result, right); | 334 result = factory.createBinary(op, result, right); |
335 } | 335 } |
336 return result; | 336 return result; |
337 } | 337 } |
338 | 338 |
339 SLExpressionNode Factor() { | 339 SLExpressionNode Factor() { |
340 SLExpressionNode result; | 340 SLExpressionNode result; |
341 result = null; | 341 result = null; |
342 if (la.kind == 1) { | 342 if (la.kind == 1) { |
343 Get(); | 343 Get(); |
344 Token nameToken = t; | 344 Token nameToken = t; |
345 if (la.kind == 5) { | 345 if (la.kind == 5) { |
346 Get(); | 346 Get(); |
347 List<SLExpressionNode> parameters = new ArrayList<>(); | 347 List<SLExpressionNode> parameters = new ArrayList<>(); |
348 SLExpressionNode parameter; | 348 SLExpressionNode parameter; |
349 if (StartOf(2)) { | 349 if (StartOf(2)) { |
350 parameter = Expression(); | 350 parameter = Expression(); |
351 parameters.add(parameter); | 351 parameters.add(parameter); |
352 while (la.kind == 6) { | 352 while (la.kind == 6) { |
353 Get(); | 353 Get(); |
354 parameter = Expression(); | 354 parameter = Expression(); |
355 parameters.add(parameter); | 355 parameters.add(parameter); |
356 } | 356 } |
357 } | 357 } |
358 result = factory.createCall(nameToken, parameters); | 358 result = factory.createCall(nameToken, parameters); |
359 Expect(7); | 359 Expect(7); |
360 } else if (la.kind == 29) { | 360 } else if (la.kind == 29) { |
361 Get(); | 361 Get(); |
362 SLExpressionNode value = Expression(); | 362 SLExpressionNode value = Expression(); |
363 result = factory.createAssignment(nameToken, value); | 363 result = factory.createAssignment(nameToken, value); |
364 } else if (StartOf(4)) { | 364 } else if (StartOf(4)) { |
365 result = factory.createRead(nameToken); | 365 result = factory.createRead(nameToken); |
366 } else SynErr(32); | 366 } else SynErr(32); |
367 } else if (la.kind == 2) { | 367 } else if (la.kind == 2) { |
368 Get(); | 368 Get(); |
369 result = factory.createStringLiteral(t); | 369 result = factory.createStringLiteral(t); |
370 } else if (la.kind == 3) { | 370 } else if (la.kind == 3) { |
371 Get(); | 371 Get(); |
372 result = factory.createNumericLiteral(t); | 372 result = factory.createNumericLiteral(t); |
373 } else if (la.kind == 5) { | 373 } else if (la.kind == 5) { |
374 Get(); | 374 Get(); |
375 result = Expression(); | 375 result = Expression(); |
376 Expect(7); | 376 Expect(7); |
377 } else SynErr(33); | 377 } else SynErr(33); |