Mercurial > hg > graal-jvmci-8

comparison graal/com.oracle.truffle.sl/src/com/oracle/truffle/sl/parser/Parser.java @ 16067:915ebb306fcc

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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);