Mercurial > hg > truffle

comparison graal/com.oracle.truffle.sl/src/com/oracle/truffle/sl/parser/Parser.java @ 13821:b16ec83edc73

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