1
2
3 package org.apache.commons.flatfile.dsl;
4
5 import java.io.IOException;
6 import java.util.Map;
7
8 import org.apache.commons.flatfile.*;
9
10 import antlr.TokenBuffer;
11 import antlr.TokenStreamException;
12 import antlr.TokenStreamIOException;
13 import antlr.ANTLRException;
14 import antlr.LLkParser;
15 import antlr.Token;
16 import antlr.TokenStream;
17 import antlr.RecognitionException;
18 import antlr.NoViableAltException;
19 import antlr.MismatchedTokenException;
20 import antlr.SemanticException;
21 import antlr.ParserSharedInputState;
22 import antlr.collections.impl.BitSet;
23 import antlr.collections.AST;
24 import java.util.Hashtable;
25 import antlr.ASTFactory;
26 import antlr.ASTPair;
27 import antlr.collections.impl.ASTArray;
28
29 public class EntityParser extends antlr.LLkParser implements EntityTokenTypes
30 {
31
32 protected EntityParser(TokenBuffer tokenBuf, int k) {
33 super(tokenBuf,k);
34 tokenNames = _tokenNames;
35 buildTokenTypeASTClassMap();
36 astFactory = new ASTFactory(getTokenTypeToASTClassMap());
37 }
38
39 public EntityParser(TokenBuffer tokenBuf) {
40 this(tokenBuf,2);
41 }
42
43 protected EntityParser(TokenStream lexer, int k) {
44 super(lexer,k);
45 tokenNames = _tokenNames;
46 buildTokenTypeASTClassMap();
47 astFactory = new ASTFactory(getTokenTypeToASTClassMap());
48 }
49
50 public EntityParser(TokenStream lexer) {
51 this(lexer,2);
52 }
53
54 public EntityParser(ParserSharedInputState state) {
55 super(state,2);
56 tokenNames = _tokenNames;
57 buildTokenTypeASTClassMap();
58 astFactory = new ASTFactory(getTokenTypeToASTClassMap());
59 }
60
61 public final void parse() throws RecognitionException, TokenStreamException {
62
63 returnAST = null;
64 ASTPair currentAST = new ASTPair();
65 AST parse_AST = null;
66
67 {
68 _loop3:
69 do {
70 if ((LA(1)==OPTION_BLOCK)) {
71 optionBlock();
72 astFactory.addASTChild(currentAST, returnAST);
73 }
74 else {
75 break _loop3;
76 }
77
78 } while (true);
79 }
80 {
81 int _cnt6=0;
82 _loop6:
83 do {
84 if ((LA(1)==IDENT)) {
85 explicitAssign();
86 astFactory.addASTChild(currentAST, returnAST);
87 {
88 switch ( LA(1)) {
89 case COLON:
90 {
91 lengthcheck();
92 astFactory.addASTChild(currentAST, returnAST);
93 break;
94 }
95 case EOF:
96 case IDENT:
97 {
98 break;
99 }
100 default:
101 {
102 throw new NoViableAltException(LT(1), getFilename());
103 }
104 }
105 }
106 }
107 else {
108 if ( _cnt6>=1 ) { break _loop6; } else {throw new NoViableAltException(LT(1), getFilename());}
109 }
110
111 _cnt6++;
112 } while (true);
113 }
114 match(Token.EOF_TYPE);
115 parse_AST = (AST)currentAST.root;
116 parse_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(ROOT,"root")).add(parse_AST));
117 currentAST.root = parse_AST;
118 currentAST.child = parse_AST!=null &&parse_AST.getFirstChild()!=null ?
119 parse_AST.getFirstChild() : parse_AST;
120 currentAST.advanceChildToEnd();
121 parse_AST = (AST)currentAST.root;
122 returnAST = parse_AST;
123 }
124
125 protected final void optionBlock() throws RecognitionException, TokenStreamException {
126
127 returnAST = null;
128 ASTPair currentAST = new ASTPair();
129 AST optionBlock_AST = null;
130 Token o = null;
131 AST o_AST = null;
132
133 o = LT(1);
134 o_AST = astFactory.create(o);
135 astFactory.makeASTRoot(currentAST, o_AST);
136 match(OPTION_BLOCK);
137 o_AST.setType(OPTIONS);
138 {
139 int _cnt9=0;
140 _loop9:
141 do {
142 if ((_tokenSet_0.member(LA(1)))) {
143 entityOption();
144 astFactory.addASTChild(currentAST, returnAST);
145 }
146 else {
147 if ( _cnt9>=1 ) { break _loop9; } else {throw new NoViableAltException(LT(1), getFilename());}
148 }
149
150 _cnt9++;
151 } while (true);
152 }
153 match(SEMI);
154 optionBlock_AST = (AST)currentAST.root;
155 returnAST = optionBlock_AST;
156 }
157
158 protected final void explicitAssign() throws RecognitionException, TokenStreamException {
159
160 returnAST = null;
161 ASTPair currentAST = new ASTPair();
162 AST explicitAssign_AST = null;
163
164 AST tmp3_AST = null;
165 tmp3_AST = astFactory.create(LT(1));
166 astFactory.addASTChild(currentAST, tmp3_AST);
167 match(IDENT);
168 entity();
169 astFactory.addASTChild(currentAST, returnAST);
170 explicitAssign_AST = (AST)currentAST.root;
171 explicitAssign_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(ASSIGN,"=")).add(explicitAssign_AST));
172 currentAST.root = explicitAssign_AST;
173 currentAST.child = explicitAssign_AST!=null &&explicitAssign_AST.getFirstChild()!=null ?
174 explicitAssign_AST.getFirstChild() : explicitAssign_AST;
175 currentAST.advanceChildToEnd();
176 explicitAssign_AST = (AST)currentAST.root;
177 returnAST = explicitAssign_AST;
178 }
179
180 protected final void lengthcheck() throws RecognitionException, TokenStreamException {
181
182 returnAST = null;
183 ASTPair currentAST = new ASTPair();
184 AST lengthcheck_AST = null;
185 Token c = null;
186 AST c_AST = null;
187
188 c = LT(1);
189 c_AST = astFactory.create(c);
190 astFactory.addASTChild(currentAST, c_AST);
191 match(COLON);
192 c_AST.setType(CHECK);
193 length();
194 astFactory.addASTChild(currentAST, returnAST);
195 lengthcheck_AST = (AST)currentAST.root;
196 returnAST = lengthcheck_AST;
197 }
198
199 protected final void entityOption() throws RecognitionException, TokenStreamException {
200
201 returnAST = null;
202 ASTPair currentAST = new ASTPair();
203 AST entityOption_AST = null;
204
205 {
206 switch ( LA(1)) {
207 case IDENT:
208 {
209 AST tmp4_AST = null;
210 tmp4_AST = astFactory.create(LT(1));
211 astFactory.addASTChild(currentAST, tmp4_AST);
212 match(IDENT);
213 break;
214 }
215 case STRING_LITERAL:
216 {
217 AST tmp5_AST = null;
218 tmp5_AST = astFactory.create(LT(1));
219 astFactory.addASTChild(currentAST, tmp5_AST);
220 match(STRING_LITERAL);
221 break;
222 }
223 case CHAR_LITERAL:
224 {
225 AST tmp6_AST = null;
226 tmp6_AST = astFactory.create(LT(1));
227 astFactory.addASTChild(currentAST, tmp6_AST);
228 match(CHAR_LITERAL);
229 break;
230 }
231 case NUMBER:
232 {
233 AST tmp7_AST = null;
234 tmp7_AST = astFactory.create(LT(1));
235 astFactory.addASTChild(currentAST, tmp7_AST);
236 match(NUMBER);
237 break;
238 }
239 default:
240 {
241 throw new NoViableAltException(LT(1), getFilename());
242 }
243 }
244 }
245 AST tmp8_AST = null;
246 tmp8_AST = astFactory.create(LT(1));
247 astFactory.makeASTRoot(currentAST, tmp8_AST);
248 match(ASSIGN);
249 {
250 switch ( LA(1)) {
251 case IDENT:
252 {
253 AST tmp9_AST = null;
254 tmp9_AST = astFactory.create(LT(1));
255 astFactory.addASTChild(currentAST, tmp9_AST);
256 match(IDENT);
257 break;
258 }
259 case STRING_LITERAL:
260 {
261 AST tmp10_AST = null;
262 tmp10_AST = astFactory.create(LT(1));
263 astFactory.addASTChild(currentAST, tmp10_AST);
264 match(STRING_LITERAL);
265 break;
266 }
267 case CHAR_LITERAL:
268 {
269 AST tmp11_AST = null;
270 tmp11_AST = astFactory.create(LT(1));
271 astFactory.addASTChild(currentAST, tmp11_AST);
272 match(CHAR_LITERAL);
273 break;
274 }
275 case NUMBER:
276 {
277 AST tmp12_AST = null;
278 tmp12_AST = astFactory.create(LT(1));
279 astFactory.addASTChild(currentAST, tmp12_AST);
280 match(NUMBER);
281 break;
282 }
283 default:
284 {
285 throw new NoViableAltException(LT(1), getFilename());
286 }
287 }
288 }
289 entityOption_AST = (AST)currentAST.root;
290 returnAST = entityOption_AST;
291 }
292
293 protected final void entity() throws RecognitionException, TokenStreamException {
294
295 returnAST = null;
296 ASTPair currentAST = new ASTPair();
297 AST entity_AST = null;
298 String junk = null;
299
300 switch ( LA(1)) {
301 case CHAR_LITERAL:
302 case STRING_LITERAL:
303 {
304 valueOnlyEntity();
305 astFactory.addASTChild(currentAST, returnAST);
306 entity_AST = (AST)currentAST.root;
307 break;
308 }
309 case TYPEREF:
310 {
311 junk=typeRefEntity();
312 astFactory.addASTChild(currentAST, returnAST);
313 entity_AST = (AST)currentAST.root;
314 break;
315 }
316 case LPAREN:
317 case LCURLY:
318 {
319 fieldOrMapEntity();
320 astFactory.addASTChild(currentAST, returnAST);
321 entity_AST = (AST)currentAST.root;
322 break;
323 }
324 default:
325 {
326 throw new NoViableAltException(LT(1), getFilename());
327 }
328 }
329 returnAST = entity_AST;
330 }
331
332 protected final void anonymousAssign() throws RecognitionException, TokenStreamException {
333
334 returnAST = null;
335 ASTPair currentAST = new ASTPair();
336 AST anonymousAssign_AST = null;
337
338 AST tmp13_AST = null;
339 tmp13_AST = astFactory.create(LT(1));
340 astFactory.addASTChild(currentAST, tmp13_AST);
341 match(ANON);
342 entity();
343 astFactory.addASTChild(currentAST, returnAST);
344 anonymousAssign_AST = (AST)currentAST.root;
345 anonymousAssign_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(ASSIGN,"=")).add(anonymousAssign_AST));
346 currentAST.root = anonymousAssign_AST;
347 currentAST.child = anonymousAssign_AST!=null &&anonymousAssign_AST.getFirstChild()!=null ?
348 anonymousAssign_AST.getFirstChild() : anonymousAssign_AST;
349 currentAST.advanceChildToEnd();
350 anonymousAssign_AST = (AST)currentAST.root;
351 returnAST = anonymousAssign_AST;
352 }
353
354 protected final void length() throws RecognitionException, TokenStreamException {
355
356 returnAST = null;
357 ASTPair currentAST = new ASTPair();
358 AST length_AST = null;
359 Token n = null;
360 AST n_AST = null;
361
362 n = LT(1);
363 n_AST = astFactory.create(n);
364 astFactory.addASTChild(currentAST, n_AST);
365 match(NUMBER);
366 n_AST.setType(LENGTH);
367 length_AST = (AST)currentAST.root;
368 returnAST = length_AST;
369 }
370
371 protected final void valueOnlyEntity() throws RecognitionException, TokenStreamException {
372
373 returnAST = null;
374 ASTPair currentAST = new ASTPair();
375 AST valueOnlyEntity_AST = null;
376 AST a_AST = null;
377 AST ast = null;
378
379 explicitValue();
380 astFactory.addASTChild(currentAST, returnAST);
381 valueOnlyEntity_AST = (AST)currentAST.root;
382 valueOnlyEntity_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FIELD,"field")).add(valueOnlyEntity_AST)); ast = valueOnlyEntity_AST;
383 currentAST.root = valueOnlyEntity_AST;
384 currentAST.child = valueOnlyEntity_AST!=null &&valueOnlyEntity_AST.getFirstChild()!=null ?
385 valueOnlyEntity_AST.getFirstChild() : valueOnlyEntity_AST;
386 currentAST.advanceChildToEnd();
387 {
388 switch ( LA(1)) {
389 case BANG:
390 {
391 immutable();
392 astFactory.addASTChild(currentAST, returnAST);
393 break;
394 }
395 case EOF:
396 case IDENT:
397 case ANON:
398 case COLON:
399 case TYPEREF:
400 case LBRACK:
401 case COMMA:
402 case RCURLY:
403 {
404 break;
405 }
406 default:
407 {
408 throw new NoViableAltException(LT(1), getFilename());
409 }
410 }
411 }
412 {
413 switch ( LA(1)) {
414 case LBRACK:
415 {
416 array(ast);
417 a_AST = (AST)returnAST;
418 valueOnlyEntity_AST = (AST)currentAST.root;
419 valueOnlyEntity_AST = a_AST;
420 currentAST.root = valueOnlyEntity_AST;
421 currentAST.child = valueOnlyEntity_AST!=null &&valueOnlyEntity_AST.getFirstChild()!=null ?
422 valueOnlyEntity_AST.getFirstChild() : valueOnlyEntity_AST;
423 currentAST.advanceChildToEnd();
424 break;
425 }
426 case EOF:
427 case IDENT:
428 case ANON:
429 case COLON:
430 case TYPEREF:
431 case COMMA:
432 case RCURLY:
433 {
434 break;
435 }
436 default:
437 {
438 throw new NoViableAltException(LT(1), getFilename());
439 }
440 }
441 }
442 valueOnlyEntity_AST = (AST)currentAST.root;
443 returnAST = valueOnlyEntity_AST;
444 }
445
446 protected final String typeRefEntity() throws RecognitionException, TokenStreamException {
447 String name;
448
449 returnAST = null;
450 ASTPair currentAST = new ASTPair();
451 AST typeRefEntity_AST = null;
452 Token t = null;
453 AST t_AST = null;
454 AST a_AST = null;
455 AST ast = null;
456
457 {
458 t = LT(1);
459 t_AST = astFactory.create(t);
460 astFactory.makeASTRoot(currentAST, t_AST);
461 match(TYPEREF);
462 name = t.getText();
463 {
464 if ((_tokenSet_0.member(LA(1))) && (LA(2)==ASSIGN)) {
465 entityOptions();
466 astFactory.addASTChild(currentAST, returnAST);
467 }
468 else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2)))) {
469 }
470 else {
471 throw new NoViableAltException(LT(1), getFilename());
472 }
473
474 }
475 {
476 switch ( LA(1)) {
477 case CHAR_LITERAL:
478 case STRING_LITERAL:
479 {
480 value();
481 astFactory.addASTChild(currentAST, returnAST);
482 break;
483 }
484 case EOF:
485 case IDENT:
486 case ANON:
487 case COLON:
488 case TYPEREF:
489 case LBRACK:
490 case COMMA:
491 case RCURLY:
492 {
493 break;
494 }
495 default:
496 {
497 throw new NoViableAltException(LT(1), getFilename());
498 }
499 }
500 }
501 }
502 typeRefEntity_AST = (AST)currentAST.root;
503 ast = typeRefEntity_AST;
504 {
505 switch ( LA(1)) {
506 case LBRACK:
507 {
508 array(ast);
509 a_AST = (AST)returnAST;
510 typeRefEntity_AST = (AST)currentAST.root;
511 typeRefEntity_AST = a_AST;
512 currentAST.root = typeRefEntity_AST;
513 currentAST.child = typeRefEntity_AST!=null &&typeRefEntity_AST.getFirstChild()!=null ?
514 typeRefEntity_AST.getFirstChild() : typeRefEntity_AST;
515 currentAST.advanceChildToEnd();
516 break;
517 }
518 case EOF:
519 case IDENT:
520 case ANON:
521 case COLON:
522 case TYPEREF:
523 case COMMA:
524 case RCURLY:
525 {
526 break;
527 }
528 default:
529 {
530 throw new NoViableAltException(LT(1), getFilename());
531 }
532 }
533 }
534 typeRefEntity_AST = (AST)currentAST.root;
535 returnAST = typeRefEntity_AST;
536 return name;
537 }
538
539 protected final void fieldOrMapEntity() throws RecognitionException, TokenStreamException {
540
541 returnAST = null;
542 ASTPair currentAST = new ASTPair();
543 AST fieldOrMapEntity_AST = null;
544 AST a_AST = null;
545 AST ast = null;
546
547 {
548 switch ( LA(1)) {
549 case LPAREN:
550 {
551 field();
552 astFactory.addASTChild(currentAST, returnAST);
553 break;
554 }
555 case LCURLY:
556 {
557 map();
558 astFactory.addASTChild(currentAST, returnAST);
559 break;
560 }
561 default:
562 {
563 throw new NoViableAltException(LT(1), getFilename());
564 }
565 }
566 }
567 fieldOrMapEntity_AST = (AST)currentAST.root;
568 ast = fieldOrMapEntity_AST;
569 {
570 switch ( LA(1)) {
571 case LBRACK:
572 {
573 array(ast);
574 a_AST = (AST)returnAST;
575 fieldOrMapEntity_AST = (AST)currentAST.root;
576 fieldOrMapEntity_AST = a_AST;
577 currentAST.root = fieldOrMapEntity_AST;
578 currentAST.child = fieldOrMapEntity_AST!=null &&fieldOrMapEntity_AST.getFirstChild()!=null ?
579 fieldOrMapEntity_AST.getFirstChild() : fieldOrMapEntity_AST;
580 currentAST.advanceChildToEnd();
581 break;
582 }
583 case EOF:
584 case IDENT:
585 case ANON:
586 case COLON:
587 case TYPEREF:
588 case COMMA:
589 case RCURLY:
590 {
591 break;
592 }
593 default:
594 {
595 throw new NoViableAltException(LT(1), getFilename());
596 }
597 }
598 }
599 fieldOrMapEntity_AST = (AST)currentAST.root;
600 returnAST = fieldOrMapEntity_AST;
601 }
602
603 protected final void explicitValue() throws RecognitionException, TokenStreamException {
604
605 returnAST = null;
606 ASTPair currentAST = new ASTPair();
607 AST explicitValue_AST = null;
608 Token c = null;
609 AST c_AST = null;
610 Token s = null;
611 AST s_AST = null;
612
613 switch ( LA(1)) {
614 case CHAR_LITERAL:
615 {
616 c = LT(1);
617 c_AST = astFactory.create(c);
618 astFactory.addASTChild(currentAST, c_AST);
619 match(CHAR_LITERAL);
620 c_AST.setType(VALUE);
621 explicitValue_AST = (AST)currentAST.root;
622 break;
623 }
624 case STRING_LITERAL:
625 {
626 s = LT(1);
627 s_AST = astFactory.create(s);
628 astFactory.addASTChild(currentAST, s_AST);
629 match(STRING_LITERAL);
630 s_AST.setType(VALUE);
631 explicitValue_AST = (AST)currentAST.root;
632 break;
633 }
634 default:
635 {
636 throw new NoViableAltException(LT(1), getFilename());
637 }
638 }
639 returnAST = explicitValue_AST;
640 }
641
642 protected final void immutable() throws RecognitionException, TokenStreamException {
643
644 returnAST = null;
645 ASTPair currentAST = new ASTPair();
646 AST immutable_AST = null;
647 Token b = null;
648 AST b_AST = null;
649
650 b = LT(1);
651 b_AST = astFactory.create(b);
652 astFactory.addASTChild(currentAST, b_AST);
653 match(BANG);
654 b_AST.setType(IMMUTABLE);
655 immutable_AST = (AST)currentAST.root;
656 returnAST = immutable_AST;
657 }
658
659 protected final void array(
660 AST p
661 ) throws RecognitionException, TokenStreamException {
662
663 returnAST = null;
664 ASTPair currentAST = new ASTPair();
665 AST array_AST = null;
666 Token a = null;
667 AST a_AST = null;
668 AST o_AST = null;
669 AST v_AST = null;
670
671 a = LT(1);
672 a_AST = astFactory.create(a);
673 astFactory.makeASTRoot(currentAST, a_AST);
674 match(LBRACK);
675 a_AST.setType(ARRAY);
676 {
677 switch ( LA(1)) {
678 case NUMBER:
679 case RANGE:
680 {
681 arrayLength();
682 astFactory.addASTChild(currentAST, returnAST);
683 break;
684 }
685 case RBRACK:
686 {
687 break;
688 }
689 default:
690 {
691 throw new NoViableAltException(LT(1), getFilename());
692 }
693 }
694 }
695 match(RBRACK);
696 array_AST = (AST)currentAST.root;
697 array_AST.addChild((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(PROTOTYPE,"prototype")).add(p)));
698 {
699 if ((_tokenSet_0.member(LA(1))) && (LA(2)==ASSIGN)) {
700 entityOptions();
701 o_AST = (AST)returnAST;
702 array_AST = (AST)currentAST.root;
703 array_AST.addChild(o_AST);
704 }
705 else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_4.member(LA(2)))) {
706 }
707 else {
708 throw new NoViableAltException(LT(1), getFilename());
709 }
710
711 }
712 {
713 switch ( LA(1)) {
714 case CHAR_LITERAL:
715 case STRING_LITERAL:
716 {
717 value();
718 v_AST = (AST)returnAST;
719 array_AST = (AST)currentAST.root;
720 array_AST.addChild(v_AST);
721 break;
722 }
723 case EOF:
724 case IDENT:
725 case ANON:
726 case COLON:
727 case TYPEREF:
728 case COMMA:
729 case RCURLY:
730 {
731 break;
732 }
733 default:
734 {
735 throw new NoViableAltException(LT(1), getFilename());
736 }
737 }
738 }
739 array_AST = (AST)currentAST.root;
740 returnAST = array_AST;
741 }
742
743 protected final void entityOptions() throws RecognitionException, TokenStreamException {
744
745 returnAST = null;
746 ASTPair currentAST = new ASTPair();
747 AST entityOptions_AST = null;
748
749 {
750 int _cnt53=0;
751 _loop53:
752 do {
753 if ((_tokenSet_0.member(LA(1))) && (LA(2)==ASSIGN)) {
754 entityOption();
755 astFactory.addASTChild(currentAST, returnAST);
756 }
757 else {
758 if ( _cnt53>=1 ) { break _loop53; } else {throw new NoViableAltException(LT(1), getFilename());}
759 }
760
761 _cnt53++;
762 } while (true);
763 }
764 entityOptions_AST = (AST)currentAST.root;
765 entityOptions_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OPTIONS,"options")).add(entityOptions_AST));
766 currentAST.root = entityOptions_AST;
767 currentAST.child = entityOptions_AST!=null &&entityOptions_AST.getFirstChild()!=null ?
768 entityOptions_AST.getFirstChild() : entityOptions_AST;
769 currentAST.advanceChildToEnd();
770 entityOptions_AST = (AST)currentAST.root;
771 returnAST = entityOptions_AST;
772 }
773
774 protected final void value() throws RecognitionException, TokenStreamException {
775
776 returnAST = null;
777 ASTPair currentAST = new ASTPair();
778 AST value_AST = null;
779
780 {
781 if ((LA(1)==CHAR_LITERAL) && (LA(2)==STAR)) {
782 fillValue();
783 astFactory.addASTChild(currentAST, returnAST);
784 }
785 else if ((LA(1)==CHAR_LITERAL||LA(1)==STRING_LITERAL) && (_tokenSet_5.member(LA(2)))) {
786 explicitValue();
787 astFactory.addASTChild(currentAST, returnAST);
788 }
789 else {
790 throw new NoViableAltException(LT(1), getFilename());
791 }
792
793 }
794 {
795 switch ( LA(1)) {
796 case BANG:
797 {
798 immutable();
799 astFactory.addASTChild(currentAST, returnAST);
800 break;
801 }
802 case EOF:
803 case IDENT:
804 case ANON:
805 case COLON:
806 case TYPEREF:
807 case LBRACK:
808 case COMMA:
809 case RCURLY:
810 {
811 break;
812 }
813 default:
814 {
815 throw new NoViableAltException(LT(1), getFilename());
816 }
817 }
818 }
819 value_AST = (AST)currentAST.root;
820 returnAST = value_AST;
821 }
822
823 protected final void field() throws RecognitionException, TokenStreamException {
824
825 returnAST = null;
826 ASTPair currentAST = new ASTPair();
827 AST field_AST = null;
828
829 match(LPAREN);
830 {
831 switch ( LA(1)) {
832 case NUMBER:
833 case RANGE:
834 {
835 arrayLength();
836 astFactory.addASTChild(currentAST, returnAST);
837 break;
838 }
839 case STAR:
840 {
841 unboundedDynamicField();
842 astFactory.addASTChild(currentAST, returnAST);
843 break;
844 }
845 default:
846 {
847 throw new NoViableAltException(LT(1), getFilename());
848 }
849 }
850 }
851 match(RPAREN);
852 {
853 if ((_tokenSet_0.member(LA(1))) && (LA(2)==ASSIGN)) {
854 entityOptions();
855 astFactory.addASTChild(currentAST, returnAST);
856 }
857 else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2)))) {
858 }
859 else {
860 throw new NoViableAltException(LT(1), getFilename());
861 }
862
863 }
864 {
865 switch ( LA(1)) {
866 case CHAR_LITERAL:
867 case STRING_LITERAL:
868 {
869 value();
870 astFactory.addASTChild(currentAST, returnAST);
871 break;
872 }
873 case EOF:
874 case IDENT:
875 case ANON:
876 case COLON:
877 case TYPEREF:
878 case LBRACK:
879 case COMMA:
880 case RCURLY:
881 {
882 break;
883 }
884 default:
885 {
886 throw new NoViableAltException(LT(1), getFilename());
887 }
888 }
889 }
890 field_AST = (AST)currentAST.root;
891 field_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FIELD,"field")).add(field_AST));
892 currentAST.root = field_AST;
893 currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
894 field_AST.getFirstChild() : field_AST;
895 currentAST.advanceChildToEnd();
896 field_AST = (AST)currentAST.root;
897 returnAST = field_AST;
898 }
899
900 protected final void map() throws RecognitionException, TokenStreamException {
901
902 returnAST = null;
903 ASTPair currentAST = new ASTPair();
904 AST map_AST = null;
905 Token m = null;
906 AST m_AST = null;
907
908 m = LT(1);
909 m_AST = astFactory.create(m);
910 astFactory.makeASTRoot(currentAST, m_AST);
911 match(LCURLY);
912 m_AST.setType(MAP);
913 mapChild();
914 astFactory.addASTChild(currentAST, returnAST);
915 {
916 _loop42:
917 do {
918 if ((_tokenSet_6.member(LA(1)))) {
919 {
920 switch ( LA(1)) {
921 case COMMA:
922 {
923 match(COMMA);
924 break;
925 }
926 case IDENT:
927 case ANON:
928 case TYPEREF:
929 {
930 break;
931 }
932 default:
933 {
934 throw new NoViableAltException(LT(1), getFilename());
935 }
936 }
937 }
938 mapChild();
939 astFactory.addASTChild(currentAST, returnAST);
940 }
941 else {
942 break _loop42;
943 }
944
945 } while (true);
946 }
947 match(RCURLY);
948 {
949 if ((_tokenSet_0.member(LA(1))) && (LA(2)==ASSIGN)) {
950 entityOptions();
951 astFactory.addASTChild(currentAST, returnAST);
952 }
953 else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2)))) {
954 }
955 else {
956 throw new NoViableAltException(LT(1), getFilename());
957 }
958
959 }
960 {
961 switch ( LA(1)) {
962 case CHAR_LITERAL:
963 case STRING_LITERAL:
964 {
965 value();
966 astFactory.addASTChild(currentAST, returnAST);
967 break;
968 }
969 case EOF:
970 case IDENT:
971 case ANON:
972 case COLON:
973 case TYPEREF:
974 case LBRACK:
975 case COMMA:
976 case RCURLY:
977 {
978 break;
979 }
980 default:
981 {
982 throw new NoViableAltException(LT(1), getFilename());
983 }
984 }
985 }
986 map_AST = (AST)currentAST.root;
987 returnAST = map_AST;
988 }
989
990 protected final void arrayLength() throws RecognitionException, TokenStreamException {
991
992 returnAST = null;
993 ASTPair currentAST = new ASTPair();
994 AST arrayLength_AST = null;
995 Token n = null;
996 AST n_AST = null;
997 Token n2 = null;
998 AST n2_AST = null;
999 Token n3 = null;
1000 AST n3_AST = null;
1001
1002 if ((LA(1)==NUMBER) && (LA(2)==RANGE)) {
1003 n = LT(1);
1004 n_AST = astFactory.create(n);
1005 astFactory.addASTChild(currentAST, n_AST);
1006 match(NUMBER);
1007 n_AST.setType(MIN);
1008 AST tmp19_AST = null;
1009 tmp19_AST = astFactory.create(LT(1));
1010 astFactory.makeASTRoot(currentAST, tmp19_AST);
1011 match(RANGE);
1012 {
1013 switch ( LA(1)) {
1014 case NUMBER:
1015 {
1016 n2 = LT(1);
1017 n2_AST = astFactory.create(n2);
1018 astFactory.addASTChild(currentAST, n2_AST);
1019 match(NUMBER);
1020 n2_AST.setType(MAX);
1021 break;
1022 }
1023 case RBRACK:
1024 case RPAREN:
1025 {
1026 break;
1027 }
1028 default:
1029 {
1030 throw new NoViableAltException(LT(1), getFilename());
1031 }
1032 }
1033 }
1034 arrayLength_AST = (AST)currentAST.root;
1035 }
1036 else if ((LA(1)==RANGE)) {
1037 AST tmp20_AST = null;
1038 tmp20_AST = astFactory.create(LT(1));
1039 astFactory.makeASTRoot(currentAST, tmp20_AST);
1040 match(RANGE);
1041 n3 = LT(1);
1042 n3_AST = astFactory.create(n3);
1043 astFactory.addASTChild(currentAST, n3_AST);
1044 match(NUMBER);
1045 n3_AST.setType(MAX);
1046 arrayLength_AST = (AST)currentAST.root;
1047 }
1048 else if ((LA(1)==NUMBER) && (LA(2)==RBRACK||LA(2)==RPAREN)) {
1049 length();
1050 astFactory.addASTChild(currentAST, returnAST);
1051 arrayLength_AST = (AST)currentAST.root;
1052 }
1053 else {
1054 throw new NoViableAltException(LT(1), getFilename());
1055 }
1056
1057 returnAST = arrayLength_AST;
1058 }
1059
1060 protected final void fillValue() throws RecognitionException, TokenStreamException {
1061
1062 returnAST = null;
1063 ASTPair currentAST = new ASTPair();
1064 AST fillValue_AST = null;
1065 Token c = null;
1066 AST c_AST = null;
1067
1068 c = LT(1);
1069 c_AST = astFactory.create(c);
1070 astFactory.addASTChild(currentAST, c_AST);
1071 match(CHAR_LITERAL);
1072 match(STAR);
1073 c_AST.setType(ALL);
1074 fillValue_AST = (AST)currentAST.root;
1075 returnAST = fillValue_AST;
1076 }
1077
1078 protected final void unboundedDynamicField() throws RecognitionException, TokenStreamException {
1079
1080 returnAST = null;
1081 ASTPair currentAST = new ASTPair();
1082 AST unboundedDynamicField_AST = null;
1083 Token s = null;
1084 AST s_AST = null;
1085
1086 s = LT(1);
1087 s_AST = astFactory.create(s);
1088 astFactory.makeASTRoot(currentAST, s_AST);
1089 match(STAR);
1090 s_AST.setType(RANGE);
1091 unboundedDynamicField_AST = (AST)currentAST.root;
1092 returnAST = unboundedDynamicField_AST;
1093 }
1094
1095 protected final void mapChild() throws RecognitionException, TokenStreamException {
1096
1097 returnAST = null;
1098 ASTPair currentAST = new ASTPair();
1099 AST mapChild_AST = null;
1100
1101 switch ( LA(1)) {
1102 case IDENT:
1103 {
1104 explicitAssign();
1105 astFactory.addASTChild(currentAST, returnAST);
1106 mapChild_AST = (AST)currentAST.root;
1107 break;
1108 }
1109 case ANON:
1110 {
1111 anonymousAssign();
1112 astFactory.addASTChild(currentAST, returnAST);
1113 mapChild_AST = (AST)currentAST.root;
1114 break;
1115 }
1116 case TYPEREF:
1117 {
1118 implicitTypeAssign();
1119 astFactory.addASTChild(currentAST, returnAST);
1120 mapChild_AST = (AST)currentAST.root;
1121 break;
1122 }
1123 default:
1124 {
1125 throw new NoViableAltException(LT(1), getFilename());
1126 }
1127 }
1128 returnAST = mapChild_AST;
1129 }
1130
1131 protected final void implicitTypeAssign() throws RecognitionException, TokenStreamException {
1132
1133 returnAST = null;
1134 ASTPair currentAST = new ASTPair();
1135 AST implicitTypeAssign_AST = null;
1136 String name = null;
1137
1138 name=typeRefEntity();
1139 astFactory.addASTChild(currentAST, returnAST);
1140 implicitTypeAssign_AST = (AST)currentAST.root;
1141 implicitTypeAssign_AST = (AST)astFactory.make( (new ASTArray(3)).add(astFactory.create(ASSIGN)).add(astFactory.create(IDENT,name)).add(implicitTypeAssign_AST));
1142 currentAST.root = implicitTypeAssign_AST;
1143 currentAST.child = implicitTypeAssign_AST!=null &&implicitTypeAssign_AST.getFirstChild()!=null ?
1144 implicitTypeAssign_AST.getFirstChild() : implicitTypeAssign_AST;
1145 currentAST.advanceChildToEnd();
1146 implicitTypeAssign_AST = (AST)currentAST.root;
1147 returnAST = implicitTypeAssign_AST;
1148 }
1149
1150
1151 public static final String[] _tokenNames = {
1152 "<0>",
1153 "EOF",
1154 "<2>",
1155 "NULL_TREE_LOOKAHEAD",
1156 "ROOT",
1157 "CHECK",
1158 "VALUE",
1159 "ALL",
1160 "FIELD",
1161 "LENGTH",
1162 "ARRAY",
1163 "IMMUTABLE",
1164 "MAP",
1165 "PROTOTYPE",
1166 "OPTIONS",
1167 "MIN",
1168 "MAX",
1169 "OPTION_BLOCK",
1170 "SEMI",
1171 "IDENT",
1172 "ANON",
1173 "COLON",
1174 "TYPEREF",
1175 "LBRACK",
1176 "RBRACK",
1177 "CHAR_LITERAL",
1178 "STAR",
1179 "STRING_LITERAL",
1180 "BANG",
1181 "LPAREN",
1182 "RPAREN",
1183 "LCURLY",
1184 "COMMA",
1185 "RCURLY",
1186 "NUMBER",
1187 "RANGE",
1188 "ASSIGN",
1189 "WS",
1190 "SL_COMMENT",
1191 "ML_COMMENT",
1192 "NL",
1193 "PTIDENT",
1194 "CHAR_BODY",
1195 "STRING_BODY",
1196 "ESC",
1197 "UNICODE",
1198 "OCTAL",
1199 "HEX_DIGIT"
1200 };
1201
1202 protected void buildTokenTypeASTClassMap() {
1203 tokenTypeToASTClassMap=null;
1204 };
1205
1206 private static final long[] mk_tokenSet_0() {
1207 long[] data = { 17348165632L, 0L};
1208 return data;
1209 }
1210 public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
1211 private static final long[] mk_tokenSet_1() {
1212 long[] data = { 13068926978L, 0L};
1213 return data;
1214 }
1215 public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
1216 private static final long[] mk_tokenSet_2() {
1217 long[] data = { 67645210626L, 0L};
1218 return data;
1219 }
1220 public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
1221 private static final long[] mk_tokenSet_3() {
1222 long[] data = { 13060538370L, 0L};
1223 return data;
1224 }
1225 public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
1226 private static final long[] mk_tokenSet_4() {
1227 long[] data = { 33268695042L, 0L};
1228 return data;
1229 }
1230 public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
1231 private static final long[] mk_tokenSet_5() {
1232 long[] data = { 13169590274L, 0L};
1233 return data;
1234 }
1235 public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
1236 private static final long[] mk_tokenSet_6() {
1237 long[] data = { 4300734464L, 0L};
1238 return data;
1239 }
1240 public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
1241
1242 }