1
2 package cz.cuni.amis.pogamut.shady;
3
4 import java.util.*;
5
6 public class ShadyParser implements ShadyParserConstants {
7 char cleanChar(String string) throws ParseException {
8 return ArgChar.parseCharacterListeral(string);
9 }
10
11 String cleanString(String string) throws ParseException {
12 return ArgString.parseStringLiteral(string);
13 }
14
15 final public ShadeTree plan() throws ParseException {
16 ShadeNode node;
17 List<ShadeNode> nodes = new ArrayList<ShadeNode>();
18 jj_consume_token(7);
19 label_1:
20 while (true) {
21 node = node();
22 nodes.add(node);
23 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
24 case 7:
25 ;
26 break;
27 default:
28 jj_la1[0] = jj_gen;
29 break label_1;
30 }
31 }
32 jj_consume_token(8);
33 jj_consume_token(0);
34 {if (true) return new ShadeTree(nodes);}
35 throw new Error("Missing return statement in function");
36 }
37
38 final public ShadeNode node() throws ParseException {
39 String name;
40 Token descr;
41 NodeElement element;
42 List<NodeElement> elements = new ArrayList<NodeElement>();
43 jj_consume_token(7);
44 jj_consume_token(6);
45 name = name();
46 descr = jj_consume_token(STRING_LITERAL);
47 label_2:
48 while (true) {
49 element = element();
50 elements.add(element);
51 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
52 case 7:
53 ;
54 break;
55 default:
56 jj_la1[1] = jj_gen;
57 break label_2;
58 }
59 }
60 jj_consume_token(8);
61 {if (true) return new ShadeNode(name, cleanString(descr.image), elements);}
62 throw new Error("Missing return statement in function");
63 }
64
65 final public NodeElement element() throws ParseException {
66 IQuery priority;
67 IQuery trigger;
68 NodeCall call;
69 jj_consume_token(7);
70 priority = priority();
71 trigger = trigger();
72 call = call();
73 jj_consume_token(8);
74 {if (true) return new NodeElement(priority, trigger, call);}
75 throw new Error("Missing return statement in function");
76 }
77
78 final public IQuery priority() throws ParseException {
79 IQuery query;
80 query = value();
81 {if (true) return query;}
82 throw new Error("Missing return statement in function");
83 }
84
85 final public IQuery trigger() throws ParseException {
86 IQuery query;
87 IQuery arg;
88 IQuery op1, op2;
89 List<IQuery> args = new LinkedList<IQuery>();
90 Token token;
91 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
92 case DECIMAL_LITERAL:
93 token = jj_consume_token(DECIMAL_LITERAL);
94 {if (true) return new QueryInt(Integer.parseInt(token.image));}
95 break;
96 case FLOATING_POINT_LITERAL:
97 token = jj_consume_token(FLOATING_POINT_LITERAL);
98 {if (true) return new QueryFloat(Double.parseDouble(token.image));}
99 break;
100 case 7:
101 jj_consume_token(7);
102 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
103 case IDENTIFIER:
104 query = queryCall();
105 {if (true) return query;}
106 break;
107 case 10:
108 jj_consume_token(10);
109 arg = trigger();
110 jj_consume_token(8);
111 {if (true) return new QueryNot(arg);}
112 break;
113 case 9:
114 jj_consume_token(9);
115 label_3:
116 while (true) {
117 arg = trigger();
118 args.add(arg);
119 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
120 case 7:
121 case DECIMAL_LITERAL:
122 case FLOATING_POINT_LITERAL:
123 ;
124 break;
125 default:
126 jj_la1[2] = jj_gen;
127 break label_3;
128 }
129 }
130 jj_consume_token(8);
131 {if (true) return new QueryAnd(args);}
132 break;
133 case 11:
134 jj_consume_token(11);
135 label_4:
136 while (true) {
137 arg = trigger();
138 args.add(arg);
139 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
140 case 7:
141 case DECIMAL_LITERAL:
142 case FLOATING_POINT_LITERAL:
143 ;
144 break;
145 default:
146 jj_la1[3] = jj_gen;
147 break label_4;
148 }
149 }
150 jj_consume_token(8);
151 {if (true) return new QueryOr(args);}
152 break;
153 case GT:
154 jj_consume_token(GT);
155 op1 = value();
156 op2 = value();
157 jj_consume_token(8);
158 {if (true) return new QueryGt(op1, op2);}
159 break;
160 case GE:
161 jj_consume_token(GE);
162 op1 = value();
163 op2 = value();
164 jj_consume_token(8);
165 {if (true) return new QueryGe(op1, op2);}
166 break;
167 case EQ:
168 jj_consume_token(EQ);
169 op1 = value();
170 op2 = value();
171 jj_consume_token(8);
172 {if (true) return new QueryEq(op1, op2);}
173 break;
174 case NE:
175 jj_consume_token(NE);
176 op1 = value();
177 op2 = value();
178 jj_consume_token(8);
179 {if (true) return new QueryNe(op1, op2);}
180 break;
181 case LE:
182 jj_consume_token(LE);
183 op1 = value();
184 op2 = value();
185 jj_consume_token(8);
186 {if (true) return new QueryLe(op1, op2);}
187 break;
188 case LT:
189 jj_consume_token(LT);
190 op1 = value();
191 op2 = value();
192 jj_consume_token(8);
193 {if (true) return new QueryLt(op1, op2);}
194 break;
195 default:
196 jj_la1[4] = jj_gen;
197 jj_consume_token(-1);
198 throw new ParseException();
199 }
200 break;
201 default:
202 jj_la1[5] = jj_gen;
203 jj_consume_token(-1);
204 throw new ParseException();
205 }
206 throw new Error("Missing return statement in function");
207 }
208
209 final public IQuery value() throws ParseException {
210 IQuery query;
211 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
212 case 7:
213 jj_consume_token(7);
214 query = queryCall();
215 {if (true) return query;}
216 break;
217 case DECIMAL_LITERAL:
218 token = jj_consume_token(DECIMAL_LITERAL);
219 {if (true) return new QueryInt(Integer.parseInt(token.image));}
220 break;
221 case FLOATING_POINT_LITERAL:
222 token = jj_consume_token(FLOATING_POINT_LITERAL);
223 {if (true) return new QueryFloat(Double.parseDouble(token.image));}
224 break;
225 default:
226 jj_la1[6] = jj_gen;
227 jj_consume_token(-1);
228 throw new ParseException();
229 }
230 throw new Error("Missing return statement in function");
231 }
232
233
234
235
236 final public QueryCall queryCall() throws ParseException {
237 String name;
238 List<IArgument> args;
239 name = name();
240 args = args();
241 jj_consume_token(8);
242 {if (true) return new QueryCall(name, args);}
243 throw new Error("Missing return statement in function");
244 }
245
246 final public NodeCall call() throws ParseException {
247 String name;
248 List<IArgument> args;
249 jj_consume_token(7);
250 name = name();
251 args = args();
252 jj_consume_token(8);
253 {if (true) return new NodeCall(name, args);}
254 throw new Error("Missing return statement in function");
255 }
256
257 final public List<IArgument> args() throws ParseException {
258 List<IArgument> args = new LinkedList<IArgument>();
259 IArgument arg;
260 label_5:
261 while (true) {
262 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
263 case DECIMAL_LITERAL:
264 case FLOATING_POINT_LITERAL:
265 case CHARACTER_LITERAL:
266 case STRING_LITERAL:
267 ;
268 break;
269 default:
270 jj_la1[7] = jj_gen;
271 break label_5;
272 }
273 arg = arg();
274 args.add(arg);
275 }
276 {if (true) return args;}
277 throw new Error("Missing return statement in function");
278 }
279
280
281 final public IArgument arg() throws ParseException {
282 Token token;
283 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
284 case DECIMAL_LITERAL:
285 token = jj_consume_token(DECIMAL_LITERAL);
286 {if (true) return new ArgInt(Integer.parseInt(token.image));}
287 break;
288 case FLOATING_POINT_LITERAL:
289 token = jj_consume_token(FLOATING_POINT_LITERAL);
290 {if (true) return new ArgFloat(Double.parseDouble(token.image));}
291 break;
292 case CHARACTER_LITERAL:
293 token = jj_consume_token(CHARACTER_LITERAL);
294 {if (true) return new ArgChar(cleanChar(token.image));}
295 break;
296 case STRING_LITERAL:
297 token = jj_consume_token(STRING_LITERAL);
298 {if (true) return new ArgString(cleanString(token.image));}
299 break;
300 default:
301 jj_la1[8] = jj_gen;
302 jj_consume_token(-1);
303 throw new ParseException();
304 }
305 throw new Error("Missing return statement in function");
306 }
307
308
309
310
311
312 final public String name() throws ParseException {
313 Token token;
314 String name;
315 token = jj_consume_token(IDENTIFIER);
316 name = token.toString();
317 label_6:
318 while (true) {
319 if (jj_2_1(2)) {
320 ;
321 } else {
322 break label_6;
323 }
324 jj_consume_token(26);
325 token = jj_consume_token(IDENTIFIER);
326 name += '.';
327 name += token.image;
328 }
329 {if (true) return name;}
330 throw new Error("Missing return statement in function");
331 }
332
333 private boolean jj_2_1(int xla) {
334 jj_la = xla; jj_lastpos = jj_scanpos = token;
335 try { return !jj_3_1(); }
336 catch(LookaheadSuccess ls) { return true; }
337 finally { jj_save(0, xla); }
338 }
339
340 private boolean jj_3_1() {
341 if (jj_scan_token(26)) return true;
342 if (jj_scan_token(IDENTIFIER)) return true;
343 return false;
344 }
345
346
347 public ShadyParserTokenManager token_source;
348 SimpleCharStream jj_input_stream;
349
350 public Token token;
351
352 public Token jj_nt;
353 private int jj_ntk;
354 private Token jj_scanpos, jj_lastpos;
355 private int jj_la;
356 private int jj_gen;
357 final private int[] jj_la1 = new int[9];
358 static private int[] jj_la1_0;
359 static {
360 jj_la1_init_0();
361 }
362 private static void jj_la1_init_0() {
363 jj_la1_0 = new int[] {0x80,0x80,0x600080,0x600080,0x7fe00,0x600080,0x600080,0x3600000,0x3600000,};
364 }
365 final private JJCalls[] jj_2_rtns = new JJCalls[1];
366 private boolean jj_rescan = false;
367 private int jj_gc = 0;
368
369
370 public ShadyParser(java.io.InputStream stream) {
371 this(stream, null);
372 }
373
374 public ShadyParser(java.io.InputStream stream, String encoding) {
375 try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
376 token_source = new ShadyParserTokenManager(jj_input_stream);
377 token = new Token();
378 jj_ntk = -1;
379 jj_gen = 0;
380 for (int i = 0; i < 9; i++) jj_la1[i] = -1;
381 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
382 }
383
384
385 public void ReInit(java.io.InputStream stream) {
386 ReInit(stream, null);
387 }
388
389 public void ReInit(java.io.InputStream stream, String encoding) {
390 try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
391 token_source.ReInit(jj_input_stream);
392 token = new Token();
393 jj_ntk = -1;
394 jj_gen = 0;
395 for (int i = 0; i < 9; i++) jj_la1[i] = -1;
396 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
397 }
398
399
400 public ShadyParser(java.io.Reader stream) {
401 jj_input_stream = new SimpleCharStream(stream, 1, 1);
402 token_source = new ShadyParserTokenManager(jj_input_stream);
403 token = new Token();
404 jj_ntk = -1;
405 jj_gen = 0;
406 for (int i = 0; i < 9; i++) jj_la1[i] = -1;
407 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
408 }
409
410
411 public void ReInit(java.io.Reader stream) {
412 jj_input_stream.ReInit(stream, 1, 1);
413 token_source.ReInit(jj_input_stream);
414 token = new Token();
415 jj_ntk = -1;
416 jj_gen = 0;
417 for (int i = 0; i < 9; i++) jj_la1[i] = -1;
418 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
419 }
420
421
422 public ShadyParser(ShadyParserTokenManager tm) {
423 token_source = tm;
424 token = new Token();
425 jj_ntk = -1;
426 jj_gen = 0;
427 for (int i = 0; i < 9; i++) jj_la1[i] = -1;
428 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
429 }
430
431
432 public void ReInit(ShadyParserTokenManager tm) {
433 token_source = tm;
434 token = new Token();
435 jj_ntk = -1;
436 jj_gen = 0;
437 for (int i = 0; i < 9; i++) jj_la1[i] = -1;
438 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
439 }
440
441 private Token jj_consume_token(int kind) throws ParseException {
442 Token oldToken;
443 if ((oldToken = token).next != null) token = token.next;
444 else token = token.next = token_source.getNextToken();
445 jj_ntk = -1;
446 if (token.kind == kind) {
447 jj_gen++;
448 if (++jj_gc > 100) {
449 jj_gc = 0;
450 for (int i = 0; i < jj_2_rtns.length; i++) {
451 JJCalls c = jj_2_rtns[i];
452 while (c != null) {
453 if (c.gen < jj_gen) c.first = null;
454 c = c.next;
455 }
456 }
457 }
458 return token;
459 }
460 token = oldToken;
461 jj_kind = kind;
462 throw generateParseException();
463 }
464
465 static private final class LookaheadSuccess extends java.lang.Error { }
466 final private LookaheadSuccess jj_ls = new LookaheadSuccess();
467 private boolean jj_scan_token(int kind) {
468 if (jj_scanpos == jj_lastpos) {
469 jj_la--;
470 if (jj_scanpos.next == null) {
471 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
472 } else {
473 jj_lastpos = jj_scanpos = jj_scanpos.next;
474 }
475 } else {
476 jj_scanpos = jj_scanpos.next;
477 }
478 if (jj_rescan) {
479 int i = 0; Token tok = token;
480 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
481 if (tok != null) jj_add_error_token(kind, i);
482 }
483 if (jj_scanpos.kind != kind) return true;
484 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
485 return false;
486 }
487
488
489
490 final public Token getNextToken() {
491 if (token.next != null) token = token.next;
492 else token = token.next = token_source.getNextToken();
493 jj_ntk = -1;
494 jj_gen++;
495 return token;
496 }
497
498
499 final public Token getToken(int index) {
500 Token t = token;
501 for (int i = 0; i < index; i++) {
502 if (t.next != null) t = t.next;
503 else t = t.next = token_source.getNextToken();
504 }
505 return t;
506 }
507
508 private int jj_ntk() {
509 if ((jj_nt=token.next) == null)
510 return (jj_ntk = (token.next=token_source.getNextToken()).kind);
511 else
512 return (jj_ntk = jj_nt.kind);
513 }
514
515 private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
516 private int[] jj_expentry;
517 private int jj_kind = -1;
518 private int[] jj_lasttokens = new int[100];
519 private int jj_endpos;
520
521 private void jj_add_error_token(int kind, int pos) {
522 if (pos >= 100) return;
523 if (pos == jj_endpos + 1) {
524 jj_lasttokens[jj_endpos++] = kind;
525 } else if (jj_endpos != 0) {
526 jj_expentry = new int[jj_endpos];
527 for (int i = 0; i < jj_endpos; i++) {
528 jj_expentry[i] = jj_lasttokens[i];
529 }
530 jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
531 int[] oldentry = (int[])(it.next());
532 if (oldentry.length == jj_expentry.length) {
533 for (int i = 0; i < jj_expentry.length; i++) {
534 if (oldentry[i] != jj_expentry[i]) {
535 continue jj_entries_loop;
536 }
537 }
538 jj_expentries.add(jj_expentry);
539 break jj_entries_loop;
540 }
541 }
542 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
543 }
544 }
545
546
547 public ParseException generateParseException() {
548 jj_expentries.clear();
549 boolean[] la1tokens = new boolean[27];
550 if (jj_kind >= 0) {
551 la1tokens[jj_kind] = true;
552 jj_kind = -1;
553 }
554 for (int i = 0; i < 9; i++) {
555 if (jj_la1[i] == jj_gen) {
556 for (int j = 0; j < 32; j++) {
557 if ((jj_la1_0[i] & (1<<j)) != 0) {
558 la1tokens[j] = true;
559 }
560 }
561 }
562 }
563 for (int i = 0; i < 27; i++) {
564 if (la1tokens[i]) {
565 jj_expentry = new int[1];
566 jj_expentry[0] = i;
567 jj_expentries.add(jj_expentry);
568 }
569 }
570 jj_endpos = 0;
571 jj_rescan_token();
572 jj_add_error_token(0, 0);
573 int[][] exptokseq = new int[jj_expentries.size()][];
574 for (int i = 0; i < jj_expentries.size(); i++) {
575 exptokseq[i] = jj_expentries.get(i);
576 }
577 return new ParseException(token, exptokseq, tokenImage);
578 }
579
580
581 final public void enable_tracing() {
582 }
583
584
585 final public void disable_tracing() {
586 }
587
588 private void jj_rescan_token() {
589 jj_rescan = true;
590 for (int i = 0; i < 1; i++) {
591 try {
592 JJCalls p = jj_2_rtns[i];
593 do {
594 if (p.gen > jj_gen) {
595 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
596 switch (i) {
597 case 0: jj_3_1(); break;
598 }
599 }
600 p = p.next;
601 } while (p != null);
602 } catch(LookaheadSuccess ls) { }
603 }
604 jj_rescan = false;
605 }
606
607 private void jj_save(int index, int xla) {
608 JJCalls p = jj_2_rtns[index];
609 while (p.gen > jj_gen) {
610 if (p.next == null) { p = p.next = new JJCalls(); break; }
611 p = p.next;
612 }
613 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
614 }
615
616 static final class JJCalls {
617 int gen;
618 Token first;
619 int arg;
620 JJCalls next;
621 }
622
623 }