1 // $ANTLR 3.3 Nov 30, 2010 12:50:56 src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g 2011-12-19 14:53:14
\r
2 package org.simantics.graph.compiler.internal.parsing;
\r
4 import org.antlr.runtime.*;
\r
5 import java.util.Stack;
\r
6 import java.util.List;
\r
7 import java.util.ArrayList;
\r
8 import java.util.Map;
\r
9 import java.util.HashMap;
\r
11 import org.antlr.runtime.tree.*;
\r
13 @SuppressWarnings("unused")
\r
14 public class GraphParser extends Parser {
\r
15 public static final String[] tokenNames = new String[] {
\r
16 "<invalid>", "<EOR>", "<DOWN>", "<UP>", "INDENT", "DEDENT", "FILE", "RESOURCE", "PROPERTY", "VARIABLE", "EMBEDDED_VALUE", "EMBEDDED_TYPE", "TEMPLATE_INSTANCE", "TEMPLATE_DEFINITION", "BLANK", "REF", "EQUALS", "INSTANCE_OF", "INHERITS", "SUBRELATION_OF", "HAS_DOMAIN", "HAS_RANGE", "DOMAIN_OF", "REQUIRES_VALUE_TYPE", "TYPE_DEFINITIONS", "TYPE_DEFINITION", "UNION_TYPE", "RECORD_TYPE", "TUPLE_TYPE", "ARRAY_TYPE", "TYPE_REFERENCE", "TYPE_ANNOTATION", "TYPE_COMPONENT", "VALUE_DEFINITIONS", "VALUE_DEFINITION", "NO_VALUE", "VARIANT", "ARRAY", "TUPLE", "TAGGED_VALUE", "RECORD", "MAP", "ASSIGNMENT", "TRUE", "FALSE", "ID", "COMMENT", "WS", "LPAREN", "RPAREN", "LBRACKET", "RBRACKET", "LCURLY", "RCURLY", "INT", "INT_RANGE", "FLOAT", "RANGE", "NEWLINE", "EXPONENT", "ESC_SEQ", "STRING", "URI", "HEX_DIGIT", "UNICODE_ESC", "'@'", "'.'", "'<T'", "'<R'", "'<--'", "'-->'", "'==>'", "'>--'", "':'", "'='", "'%'", "'$'", "'|'", "','", "'true'", "'false'"
\r
18 public static final int EOF=-1;
\r
19 public static final int T__65=65;
\r
20 public static final int T__66=66;
\r
21 public static final int T__67=67;
\r
22 public static final int T__68=68;
\r
23 public static final int T__69=69;
\r
24 public static final int T__70=70;
\r
25 public static final int T__71=71;
\r
26 public static final int T__72=72;
\r
27 public static final int T__73=73;
\r
28 public static final int T__74=74;
\r
29 public static final int T__75=75;
\r
30 public static final int T__76=76;
\r
31 public static final int T__77=77;
\r
32 public static final int T__78=78;
\r
33 public static final int T__79=79;
\r
34 public static final int T__80=80;
\r
35 public static final int INDENT=4;
\r
36 public static final int DEDENT=5;
\r
37 public static final int FILE=6;
\r
38 public static final int RESOURCE=7;
\r
39 public static final int PROPERTY=8;
\r
40 public static final int VARIABLE=9;
\r
41 public static final int EMBEDDED_VALUE=10;
\r
42 public static final int EMBEDDED_TYPE=11;
\r
43 public static final int TEMPLATE_INSTANCE=12;
\r
44 public static final int TEMPLATE_DEFINITION=13;
\r
45 public static final int BLANK=14;
\r
46 public static final int REF=15;
\r
47 public static final int EQUALS=16;
\r
48 public static final int INSTANCE_OF=17;
\r
49 public static final int INHERITS=18;
\r
50 public static final int SUBRELATION_OF=19;
\r
51 public static final int HAS_DOMAIN=20;
\r
52 public static final int HAS_RANGE=21;
\r
53 public static final int DOMAIN_OF=22;
\r
54 public static final int REQUIRES_VALUE_TYPE=23;
\r
55 public static final int TYPE_DEFINITIONS=24;
\r
56 public static final int TYPE_DEFINITION=25;
\r
57 public static final int UNION_TYPE=26;
\r
58 public static final int RECORD_TYPE=27;
\r
59 public static final int TUPLE_TYPE=28;
\r
60 public static final int ARRAY_TYPE=29;
\r
61 public static final int TYPE_REFERENCE=30;
\r
62 public static final int TYPE_ANNOTATION=31;
\r
63 public static final int TYPE_COMPONENT=32;
\r
64 public static final int VALUE_DEFINITIONS=33;
\r
65 public static final int VALUE_DEFINITION=34;
\r
66 public static final int NO_VALUE=35;
\r
67 public static final int VARIANT=36;
\r
68 public static final int ARRAY=37;
\r
69 public static final int TUPLE=38;
\r
70 public static final int TAGGED_VALUE=39;
\r
71 public static final int RECORD=40;
\r
72 public static final int MAP=41;
\r
73 public static final int ASSIGNMENT=42;
\r
74 public static final int TRUE=43;
\r
75 public static final int FALSE=44;
\r
76 public static final int ID=45;
\r
77 public static final int COMMENT=46;
\r
78 public static final int WS=47;
\r
79 public static final int LPAREN=48;
\r
80 public static final int RPAREN=49;
\r
81 public static final int LBRACKET=50;
\r
82 public static final int RBRACKET=51;
\r
83 public static final int LCURLY=52;
\r
84 public static final int RCURLY=53;
\r
85 public static final int INT=54;
\r
86 public static final int INT_RANGE=55;
\r
87 public static final int FLOAT=56;
\r
88 public static final int RANGE=57;
\r
89 public static final int NEWLINE=58;
\r
90 public static final int EXPONENT=59;
\r
91 public static final int ESC_SEQ=60;
\r
92 public static final int STRING=61;
\r
93 public static final int URI=62;
\r
94 public static final int HEX_DIGIT=63;
\r
95 public static final int UNICODE_ESC=64;
\r
101 public GraphParser(TokenStream input) {
\r
102 this(input, new RecognizerSharedState());
\r
104 public GraphParser(TokenStream input, RecognizerSharedState state) {
\r
105 super(input, state);
\r
109 protected TreeAdaptor adaptor = new CommonTreeAdaptor();
\r
111 public void setTreeAdaptor(TreeAdaptor adaptor) {
\r
112 this.adaptor = adaptor;
\r
114 public TreeAdaptor getTreeAdaptor() {
\r
118 public String[] getTokenNames() { return GraphParser.tokenNames; }
\r
119 public String getGrammarFileName() { return "src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g"; }
\r
122 public static class file_return extends ParserRuleReturnScope {
\r
124 public Object getTree() { return tree; }
\r
127 // $ANTLR start "file"
\r
128 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:224:1: file : ( NEWLINE )? ( resourceDefinitions )? EOF -> ^( FILE ( resourceDefinitions )? ) ;
\r
129 public final GraphParser.file_return file() throws RecognitionException {
\r
130 GraphParser.file_return retval = new GraphParser.file_return();
\r
131 retval.start = input.LT(1);
\r
133 CommonTree root_0 = null;
\r
135 Token NEWLINE1=null;
\r
137 GraphParser.resourceDefinitions_return resourceDefinitions2 = null;
\r
140 CommonTree NEWLINE1_tree=null;
\r
141 CommonTree EOF3_tree=null;
\r
142 RewriteRuleTokenStream stream_NEWLINE=new RewriteRuleTokenStream(adaptor,"token NEWLINE");
\r
143 RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
\r
144 RewriteRuleSubtreeStream stream_resourceDefinitions=new RewriteRuleSubtreeStream(adaptor,"rule resourceDefinitions");
\r
146 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:224:6: ( ( NEWLINE )? ( resourceDefinitions )? EOF -> ^( FILE ( resourceDefinitions )? ) )
\r
147 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:224:8: ( NEWLINE )? ( resourceDefinitions )? EOF
\r
149 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:224:8: ( NEWLINE )?
\r
151 int LA1_0 = input.LA(1);
\r
153 if ( (LA1_0==NEWLINE) ) {
\r
158 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:224:8: NEWLINE
\r
160 NEWLINE1=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_file1230); if (state.failed) return retval;
\r
161 if ( state.backtracking==0 ) stream_NEWLINE.add(NEWLINE1);
\r
169 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:224:17: ( resourceDefinitions )?
\r
171 int LA2_0 = input.LA(1);
\r
173 if ( (LA2_0==ID||LA2_0==LPAREN||LA2_0==LBRACKET||LA2_0==LCURLY||LA2_0==INT||LA2_0==FLOAT||(LA2_0>=STRING && LA2_0<=URI)||LA2_0==65||(LA2_0>=75 && LA2_0<=76)||(LA2_0>=79 && LA2_0<=80)) ) {
\r
178 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:224:17: resourceDefinitions
\r
180 pushFollow(FOLLOW_resourceDefinitions_in_file1233);
\r
181 resourceDefinitions2=resourceDefinitions();
\r
184 if (state.failed) return retval;
\r
185 if ( state.backtracking==0 ) stream_resourceDefinitions.add(resourceDefinitions2.getTree());
\r
192 EOF3=(Token)match(input,EOF,FOLLOW_EOF_in_file1236); if (state.failed) return retval;
\r
193 if ( state.backtracking==0 ) stream_EOF.add(EOF3);
\r
198 // elements: resourceDefinitions
\r
200 // rule labels: retval
\r
201 // token list labels:
\r
202 // rule list labels:
\r
203 // wildcard labels:
\r
204 if ( state.backtracking==0 ) {
\r
205 retval.tree = root_0;
\r
206 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
208 root_0 = (CommonTree)adaptor.nil();
\r
209 // 224:42: -> ^( FILE ( resourceDefinitions )? )
\r
211 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:224:45: ^( FILE ( resourceDefinitions )? )
\r
213 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
214 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(FILE, "FILE"), root_1);
\r
216 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:224:52: ( resourceDefinitions )?
\r
217 if ( stream_resourceDefinitions.hasNext() ) {
\r
218 adaptor.addChild(root_1, stream_resourceDefinitions.nextTree());
\r
221 stream_resourceDefinitions.reset();
\r
223 adaptor.addChild(root_0, root_1);
\r
228 retval.tree = root_0;}
\r
231 retval.stop = input.LT(-1);
\r
233 if ( state.backtracking==0 ) {
\r
235 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
236 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
239 catch (RecognitionException re) {
\r
242 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
249 // $ANTLR end "file"
\r
251 public static class resourceDefinitions_return extends ParserRuleReturnScope {
\r
253 public Object getTree() { return tree; }
\r
256 // $ANTLR start "resourceDefinitions"
\r
257 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:226:1: resourceDefinitions : resourceDefinition ( NEWLINE resourceDefinition )* ;
\r
258 public final GraphParser.resourceDefinitions_return resourceDefinitions() throws RecognitionException {
\r
259 GraphParser.resourceDefinitions_return retval = new GraphParser.resourceDefinitions_return();
\r
260 retval.start = input.LT(1);
\r
262 CommonTree root_0 = null;
\r
264 Token NEWLINE5=null;
\r
265 GraphParser.resourceDefinition_return resourceDefinition4 = null;
\r
267 GraphParser.resourceDefinition_return resourceDefinition6 = null;
\r
270 CommonTree NEWLINE5_tree=null;
\r
273 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:227:6: ( resourceDefinition ( NEWLINE resourceDefinition )* )
\r
274 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:227:8: resourceDefinition ( NEWLINE resourceDefinition )*
\r
276 root_0 = (CommonTree)adaptor.nil();
\r
278 pushFollow(FOLLOW_resourceDefinition_in_resourceDefinitions1260);
\r
279 resourceDefinition4=resourceDefinition();
\r
282 if (state.failed) return retval;
\r
283 if ( state.backtracking==0 ) adaptor.addChild(root_0, resourceDefinition4.getTree());
\r
284 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:227:27: ( NEWLINE resourceDefinition )*
\r
288 int LA3_0 = input.LA(1);
\r
290 if ( (LA3_0==NEWLINE) ) {
\r
297 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:227:28: NEWLINE resourceDefinition
\r
299 NEWLINE5=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_resourceDefinitions1263); if (state.failed) return retval;
\r
300 pushFollow(FOLLOW_resourceDefinition_in_resourceDefinitions1266);
\r
301 resourceDefinition6=resourceDefinition();
\r
304 if (state.failed) return retval;
\r
305 if ( state.backtracking==0 ) adaptor.addChild(root_0, resourceDefinition6.getTree());
\r
318 retval.stop = input.LT(-1);
\r
320 if ( state.backtracking==0 ) {
\r
322 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
323 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
326 catch (RecognitionException re) {
\r
329 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
336 // $ANTLR end "resourceDefinitions"
\r
338 public static class resourceDefinition_return extends ParserRuleReturnScope {
\r
340 public Object getTree() { return tree; }
\r
343 // $ANTLR start "resourceDefinition"
\r
344 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:230:1: resourceDefinition : ( resource ( localProperty )* ( INDENT property ( NEWLINE property )* DEDENT )? -> ^( RESOURCE resource ( localProperty )* ( property )* ) | template -> ^( RESOURCE ^( BLANK template ) template ) );
\r
345 public final GraphParser.resourceDefinition_return resourceDefinition() throws RecognitionException {
\r
346 GraphParser.resourceDefinition_return retval = new GraphParser.resourceDefinition_return();
\r
347 retval.start = input.LT(1);
\r
349 CommonTree root_0 = null;
\r
351 Token INDENT9=null;
\r
352 Token NEWLINE11=null;
\r
353 Token DEDENT13=null;
\r
354 GraphParser.resource_return resource7 = null;
\r
356 GraphParser.localProperty_return localProperty8 = null;
\r
358 GraphParser.property_return property10 = null;
\r
360 GraphParser.property_return property12 = null;
\r
362 GraphParser.template_return template14 = null;
\r
365 CommonTree INDENT9_tree=null;
\r
366 CommonTree NEWLINE11_tree=null;
\r
367 CommonTree DEDENT13_tree=null;
\r
368 RewriteRuleTokenStream stream_DEDENT=new RewriteRuleTokenStream(adaptor,"token DEDENT");
\r
369 RewriteRuleTokenStream stream_NEWLINE=new RewriteRuleTokenStream(adaptor,"token NEWLINE");
\r
370 RewriteRuleTokenStream stream_INDENT=new RewriteRuleTokenStream(adaptor,"token INDENT");
\r
371 RewriteRuleSubtreeStream stream_template=new RewriteRuleSubtreeStream(adaptor,"rule template");
\r
372 RewriteRuleSubtreeStream stream_resource=new RewriteRuleSubtreeStream(adaptor,"rule resource");
\r
373 RewriteRuleSubtreeStream stream_property=new RewriteRuleSubtreeStream(adaptor,"rule property");
\r
374 RewriteRuleSubtreeStream stream_localProperty=new RewriteRuleSubtreeStream(adaptor,"rule localProperty");
\r
376 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:231:5: ( resource ( localProperty )* ( INDENT property ( NEWLINE property )* DEDENT )? -> ^( RESOURCE resource ( localProperty )* ( property )* ) | template -> ^( RESOURCE ^( BLANK template ) template ) )
\r
378 int LA7_0 = input.LA(1);
\r
380 if ( (LA7_0==ID||LA7_0==LPAREN||LA7_0==LBRACKET||LA7_0==LCURLY||LA7_0==INT||LA7_0==FLOAT||(LA7_0>=STRING && LA7_0<=URI)||(LA7_0>=75 && LA7_0<=76)||(LA7_0>=79 && LA7_0<=80)) ) {
\r
383 else if ( (LA7_0==65) ) {
\r
387 if (state.backtracking>0) {state.failed=true; return retval;}
\r
388 NoViableAltException nvae =
\r
389 new NoViableAltException("", 7, 0, input);
\r
395 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:231:7: resource ( localProperty )* ( INDENT property ( NEWLINE property )* DEDENT )?
\r
397 pushFollow(FOLLOW_resource_in_resourceDefinition1300);
\r
398 resource7=resource();
\r
401 if (state.failed) return retval;
\r
402 if ( state.backtracking==0 ) stream_resource.add(resource7.getTree());
\r
403 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:232:7: ( localProperty )*
\r
407 int LA4_0 = input.LA(1);
\r
409 if ( (LA4_0==ID||LA4_0==URI||(LA4_0>=67 && LA4_0<=75)) ) {
\r
416 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:232:7: localProperty
\r
418 pushFollow(FOLLOW_localProperty_in_resourceDefinition1308);
\r
419 localProperty8=localProperty();
\r
422 if (state.failed) return retval;
\r
423 if ( state.backtracking==0 ) stream_localProperty.add(localProperty8.getTree());
\r
433 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:233:7: ( INDENT property ( NEWLINE property )* DEDENT )?
\r
435 int LA6_0 = input.LA(1);
\r
437 if ( (LA6_0==INDENT) ) {
\r
442 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:233:8: INDENT property ( NEWLINE property )* DEDENT
\r
444 INDENT9=(Token)match(input,INDENT,FOLLOW_INDENT_in_resourceDefinition1318); if (state.failed) return retval;
\r
445 if ( state.backtracking==0 ) stream_INDENT.add(INDENT9);
\r
447 pushFollow(FOLLOW_property_in_resourceDefinition1320);
\r
448 property10=property();
\r
451 if (state.failed) return retval;
\r
452 if ( state.backtracking==0 ) stream_property.add(property10.getTree());
\r
453 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:233:24: ( NEWLINE property )*
\r
457 int LA5_0 = input.LA(1);
\r
459 if ( (LA5_0==NEWLINE) ) {
\r
466 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:233:25: NEWLINE property
\r
468 NEWLINE11=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_resourceDefinition1323); if (state.failed) return retval;
\r
469 if ( state.backtracking==0 ) stream_NEWLINE.add(NEWLINE11);
\r
471 pushFollow(FOLLOW_property_in_resourceDefinition1325);
\r
472 property12=property();
\r
475 if (state.failed) return retval;
\r
476 if ( state.backtracking==0 ) stream_property.add(property12.getTree());
\r
486 DEDENT13=(Token)match(input,DEDENT,FOLLOW_DEDENT_in_resourceDefinition1329); if (state.failed) return retval;
\r
487 if ( state.backtracking==0 ) stream_DEDENT.add(DEDENT13);
\r
498 // elements: property, localProperty, resource
\r
500 // rule labels: retval
\r
501 // token list labels:
\r
502 // rule list labels:
\r
503 // wildcard labels:
\r
504 if ( state.backtracking==0 ) {
\r
505 retval.tree = root_0;
\r
506 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
508 root_0 = (CommonTree)adaptor.nil();
\r
509 // 234:5: -> ^( RESOURCE resource ( localProperty )* ( property )* )
\r
511 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:234:8: ^( RESOURCE resource ( localProperty )* ( property )* )
\r
513 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
514 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(RESOURCE, "RESOURCE"), root_1);
\r
516 adaptor.addChild(root_1, stream_resource.nextTree());
\r
517 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:234:28: ( localProperty )*
\r
518 while ( stream_localProperty.hasNext() ) {
\r
519 adaptor.addChild(root_1, stream_localProperty.nextTree());
\r
522 stream_localProperty.reset();
\r
523 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:234:43: ( property )*
\r
524 while ( stream_property.hasNext() ) {
\r
525 adaptor.addChild(root_1, stream_property.nextTree());
\r
528 stream_property.reset();
\r
530 adaptor.addChild(root_0, root_1);
\r
535 retval.tree = root_0;}
\r
539 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:235:7: template
\r
541 pushFollow(FOLLOW_template_in_resourceDefinition1358);
\r
542 template14=template();
\r
545 if (state.failed) return retval;
\r
546 if ( state.backtracking==0 ) stream_template.add(template14.getTree());
\r
550 // elements: template, template
\r
552 // rule labels: retval
\r
553 // token list labels:
\r
554 // rule list labels:
\r
555 // wildcard labels:
\r
556 if ( state.backtracking==0 ) {
\r
557 retval.tree = root_0;
\r
558 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
560 root_0 = (CommonTree)adaptor.nil();
\r
561 // 235:16: -> ^( RESOURCE ^( BLANK template ) template )
\r
563 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:235:19: ^( RESOURCE ^( BLANK template ) template )
\r
565 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
566 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(RESOURCE, "RESOURCE"), root_1);
\r
568 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:235:30: ^( BLANK template )
\r
570 CommonTree root_2 = (CommonTree)adaptor.nil();
\r
571 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(BLANK, "BLANK"), root_2);
\r
573 adaptor.addChild(root_2, stream_template.nextTree());
\r
575 adaptor.addChild(root_1, root_2);
\r
577 adaptor.addChild(root_1, stream_template.nextTree());
\r
579 adaptor.addChild(root_0, root_1);
\r
584 retval.tree = root_0;}
\r
589 retval.stop = input.LT(-1);
\r
591 if ( state.backtracking==0 ) {
\r
593 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
594 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
597 catch (RecognitionException re) {
\r
600 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
607 // $ANTLR end "resourceDefinition"
\r
609 public static class localProperty_return extends ParserRuleReturnScope {
\r
611 public Object getTree() { return tree; }
\r
614 // $ANTLR start "localProperty"
\r
615 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:238:1: localProperty : relation resource -> ^( PROPERTY relation ^( RESOURCE resource ) ) ;
\r
616 public final GraphParser.localProperty_return localProperty() throws RecognitionException {
\r
617 GraphParser.localProperty_return retval = new GraphParser.localProperty_return();
\r
618 retval.start = input.LT(1);
\r
620 CommonTree root_0 = null;
\r
622 GraphParser.relation_return relation15 = null;
\r
624 GraphParser.resource_return resource16 = null;
\r
627 RewriteRuleSubtreeStream stream_relation=new RewriteRuleSubtreeStream(adaptor,"rule relation");
\r
628 RewriteRuleSubtreeStream stream_resource=new RewriteRuleSubtreeStream(adaptor,"rule resource");
\r
630 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:239:5: ( relation resource -> ^( PROPERTY relation ^( RESOURCE resource ) ) )
\r
631 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:239:7: relation resource
\r
633 pushFollow(FOLLOW_relation_in_localProperty1393);
\r
634 relation15=relation();
\r
637 if (state.failed) return retval;
\r
638 if ( state.backtracking==0 ) stream_relation.add(relation15.getTree());
\r
639 pushFollow(FOLLOW_resource_in_localProperty1395);
\r
640 resource16=resource();
\r
643 if (state.failed) return retval;
\r
644 if ( state.backtracking==0 ) stream_resource.add(resource16.getTree());
\r
648 // elements: resource, relation
\r
650 // rule labels: retval
\r
651 // token list labels:
\r
652 // rule list labels:
\r
653 // wildcard labels:
\r
654 if ( state.backtracking==0 ) {
\r
655 retval.tree = root_0;
\r
656 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
658 root_0 = (CommonTree)adaptor.nil();
\r
659 // 240:5: -> ^( PROPERTY relation ^( RESOURCE resource ) )
\r
661 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:240:8: ^( PROPERTY relation ^( RESOURCE resource ) )
\r
663 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
664 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(PROPERTY, "PROPERTY"), root_1);
\r
666 adaptor.addChild(root_1, stream_relation.nextTree());
\r
667 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:240:28: ^( RESOURCE resource )
\r
669 CommonTree root_2 = (CommonTree)adaptor.nil();
\r
670 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(RESOURCE, "RESOURCE"), root_2);
\r
672 adaptor.addChild(root_2, stream_resource.nextTree());
\r
674 adaptor.addChild(root_1, root_2);
\r
677 adaptor.addChild(root_0, root_1);
\r
682 retval.tree = root_0;}
\r
685 retval.stop = input.LT(-1);
\r
687 if ( state.backtracking==0 ) {
\r
689 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
690 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
693 catch (RecognitionException re) {
\r
696 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
703 // $ANTLR end "localProperty"
\r
705 public static class property_return extends ParserRuleReturnScope {
\r
707 public Object getTree() { return tree; }
\r
710 // $ANTLR start "property"
\r
711 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:243:1: property : ( relation ( resourceDefinition -> ^( PROPERTY relation resourceDefinition ) | INDENT resourceDefinitions DEDENT -> ^( PROPERTY relation resourceDefinitions ) ) | template );
\r
712 public final GraphParser.property_return property() throws RecognitionException {
\r
713 GraphParser.property_return retval = new GraphParser.property_return();
\r
714 retval.start = input.LT(1);
\r
716 CommonTree root_0 = null;
\r
718 Token INDENT19=null;
\r
719 Token DEDENT21=null;
\r
720 GraphParser.relation_return relation17 = null;
\r
722 GraphParser.resourceDefinition_return resourceDefinition18 = null;
\r
724 GraphParser.resourceDefinitions_return resourceDefinitions20 = null;
\r
726 GraphParser.template_return template22 = null;
\r
729 CommonTree INDENT19_tree=null;
\r
730 CommonTree DEDENT21_tree=null;
\r
731 RewriteRuleTokenStream stream_DEDENT=new RewriteRuleTokenStream(adaptor,"token DEDENT");
\r
732 RewriteRuleTokenStream stream_INDENT=new RewriteRuleTokenStream(adaptor,"token INDENT");
\r
733 RewriteRuleSubtreeStream stream_resourceDefinition=new RewriteRuleSubtreeStream(adaptor,"rule resourceDefinition");
\r
734 RewriteRuleSubtreeStream stream_relation=new RewriteRuleSubtreeStream(adaptor,"rule relation");
\r
735 RewriteRuleSubtreeStream stream_resourceDefinitions=new RewriteRuleSubtreeStream(adaptor,"rule resourceDefinitions");
\r
737 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:244:5: ( relation ( resourceDefinition -> ^( PROPERTY relation resourceDefinition ) | INDENT resourceDefinitions DEDENT -> ^( PROPERTY relation resourceDefinitions ) ) | template )
\r
739 int LA9_0 = input.LA(1);
\r
741 if ( (LA9_0==ID||LA9_0==URI||(LA9_0>=67 && LA9_0<=75)) ) {
\r
744 else if ( (LA9_0==65) ) {
\r
748 if (state.backtracking>0) {state.failed=true; return retval;}
\r
749 NoViableAltException nvae =
\r
750 new NoViableAltException("", 9, 0, input);
\r
756 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:244:7: relation ( resourceDefinition -> ^( PROPERTY relation resourceDefinition ) | INDENT resourceDefinitions DEDENT -> ^( PROPERTY relation resourceDefinitions ) )
\r
758 pushFollow(FOLLOW_relation_in_property1434);
\r
759 relation17=relation();
\r
762 if (state.failed) return retval;
\r
763 if ( state.backtracking==0 ) stream_relation.add(relation17.getTree());
\r
764 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:245:7: ( resourceDefinition -> ^( PROPERTY relation resourceDefinition ) | INDENT resourceDefinitions DEDENT -> ^( PROPERTY relation resourceDefinitions ) )
\r
766 int LA8_0 = input.LA(1);
\r
768 if ( (LA8_0==ID||LA8_0==LPAREN||LA8_0==LBRACKET||LA8_0==LCURLY||LA8_0==INT||LA8_0==FLOAT||(LA8_0>=STRING && LA8_0<=URI)||LA8_0==65||(LA8_0>=75 && LA8_0<=76)||(LA8_0>=79 && LA8_0<=80)) ) {
\r
771 else if ( (LA8_0==INDENT) ) {
\r
775 if (state.backtracking>0) {state.failed=true; return retval;}
\r
776 NoViableAltException nvae =
\r
777 new NoViableAltException("", 8, 0, input);
\r
783 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:245:9: resourceDefinition
\r
785 pushFollow(FOLLOW_resourceDefinition_in_property1444);
\r
786 resourceDefinition18=resourceDefinition();
\r
789 if (state.failed) return retval;
\r
790 if ( state.backtracking==0 ) stream_resourceDefinition.add(resourceDefinition18.getTree());
\r
794 // elements: relation, resourceDefinition
\r
796 // rule labels: retval
\r
797 // token list labels:
\r
798 // rule list labels:
\r
799 // wildcard labels:
\r
800 if ( state.backtracking==0 ) {
\r
801 retval.tree = root_0;
\r
802 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
804 root_0 = (CommonTree)adaptor.nil();
\r
805 // 245:28: -> ^( PROPERTY relation resourceDefinition )
\r
807 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:245:31: ^( PROPERTY relation resourceDefinition )
\r
809 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
810 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(PROPERTY, "PROPERTY"), root_1);
\r
812 adaptor.addChild(root_1, stream_relation.nextTree());
\r
813 adaptor.addChild(root_1, stream_resourceDefinition.nextTree());
\r
815 adaptor.addChild(root_0, root_1);
\r
820 retval.tree = root_0;}
\r
824 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:246:9: INDENT resourceDefinitions DEDENT
\r
826 INDENT19=(Token)match(input,INDENT,FOLLOW_INDENT_in_property1464); if (state.failed) return retval;
\r
827 if ( state.backtracking==0 ) stream_INDENT.add(INDENT19);
\r
829 pushFollow(FOLLOW_resourceDefinitions_in_property1466);
\r
830 resourceDefinitions20=resourceDefinitions();
\r
833 if (state.failed) return retval;
\r
834 if ( state.backtracking==0 ) stream_resourceDefinitions.add(resourceDefinitions20.getTree());
\r
835 DEDENT21=(Token)match(input,DEDENT,FOLLOW_DEDENT_in_property1468); if (state.failed) return retval;
\r
836 if ( state.backtracking==0 ) stream_DEDENT.add(DEDENT21);
\r
841 // elements: relation, resourceDefinitions
\r
843 // rule labels: retval
\r
844 // token list labels:
\r
845 // rule list labels:
\r
846 // wildcard labels:
\r
847 if ( state.backtracking==0 ) {
\r
848 retval.tree = root_0;
\r
849 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
851 root_0 = (CommonTree)adaptor.nil();
\r
852 // 246:43: -> ^( PROPERTY relation resourceDefinitions )
\r
854 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:246:46: ^( PROPERTY relation resourceDefinitions )
\r
856 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
857 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(PROPERTY, "PROPERTY"), root_1);
\r
859 adaptor.addChild(root_1, stream_relation.nextTree());
\r
860 adaptor.addChild(root_1, stream_resourceDefinitions.nextTree());
\r
862 adaptor.addChild(root_0, root_1);
\r
867 retval.tree = root_0;}
\r
877 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:248:7: template
\r
879 root_0 = (CommonTree)adaptor.nil();
\r
881 pushFollow(FOLLOW_template_in_property1494);
\r
882 template22=template();
\r
885 if (state.failed) return retval;
\r
886 if ( state.backtracking==0 ) adaptor.addChild(root_0, template22.getTree());
\r
892 retval.stop = input.LT(-1);
\r
894 if ( state.backtracking==0 ) {
\r
896 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
897 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
900 catch (RecognitionException re) {
\r
903 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
910 // $ANTLR end "property"
\r
912 public static class template_return extends ParserRuleReturnScope {
\r
914 public Object getTree() { return tree; }
\r
917 // $ANTLR start "template"
\r
918 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:251:1: template : '@' ({...}? => ID ( resource )+ INDENT resourceDefinitions DEDENT -> ^( TEMPLATE_DEFINITION ( resource )+ resourceDefinitions ) | ( resource )+ ( INDENT resourceDefinitions DEDENT )? -> ^( TEMPLATE_INSTANCE ( resource )+ ( resourceDefinitions )? ) ) ;
\r
919 public final GraphParser.template_return template() throws RecognitionException {
\r
920 GraphParser.template_return retval = new GraphParser.template_return();
\r
921 retval.start = input.LT(1);
\r
923 CommonTree root_0 = null;
\r
925 Token char_literal23=null;
\r
927 Token INDENT26=null;
\r
928 Token DEDENT28=null;
\r
929 Token INDENT30=null;
\r
930 Token DEDENT32=null;
\r
931 GraphParser.resource_return resource25 = null;
\r
933 GraphParser.resourceDefinitions_return resourceDefinitions27 = null;
\r
935 GraphParser.resource_return resource29 = null;
\r
937 GraphParser.resourceDefinitions_return resourceDefinitions31 = null;
\r
940 CommonTree char_literal23_tree=null;
\r
941 CommonTree ID24_tree=null;
\r
942 CommonTree INDENT26_tree=null;
\r
943 CommonTree DEDENT28_tree=null;
\r
944 CommonTree INDENT30_tree=null;
\r
945 CommonTree DEDENT32_tree=null;
\r
946 RewriteRuleTokenStream stream_DEDENT=new RewriteRuleTokenStream(adaptor,"token DEDENT");
\r
947 RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
\r
948 RewriteRuleTokenStream stream_65=new RewriteRuleTokenStream(adaptor,"token 65");
\r
949 RewriteRuleTokenStream stream_INDENT=new RewriteRuleTokenStream(adaptor,"token INDENT");
\r
950 RewriteRuleSubtreeStream stream_resource=new RewriteRuleSubtreeStream(adaptor,"rule resource");
\r
951 RewriteRuleSubtreeStream stream_resourceDefinitions=new RewriteRuleSubtreeStream(adaptor,"rule resourceDefinitions");
\r
953 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:252:5: ( '@' ({...}? => ID ( resource )+ INDENT resourceDefinitions DEDENT -> ^( TEMPLATE_DEFINITION ( resource )+ resourceDefinitions ) | ( resource )+ ( INDENT resourceDefinitions DEDENT )? -> ^( TEMPLATE_INSTANCE ( resource )+ ( resourceDefinitions )? ) ) )
\r
954 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:252:7: '@' ({...}? => ID ( resource )+ INDENT resourceDefinitions DEDENT -> ^( TEMPLATE_DEFINITION ( resource )+ resourceDefinitions ) | ( resource )+ ( INDENT resourceDefinitions DEDENT )? -> ^( TEMPLATE_INSTANCE ( resource )+ ( resourceDefinitions )? ) )
\r
956 char_literal23=(Token)match(input,65,FOLLOW_65_in_template1515); if (state.failed) return retval;
\r
957 if ( state.backtracking==0 ) stream_65.add(char_literal23);
\r
959 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:253:5: ({...}? => ID ( resource )+ INDENT resourceDefinitions DEDENT -> ^( TEMPLATE_DEFINITION ( resource )+ resourceDefinitions ) | ( resource )+ ( INDENT resourceDefinitions DEDENT )? -> ^( TEMPLATE_INSTANCE ( resource )+ ( resourceDefinitions )? ) )
\r
961 alt13 = dfa13.predict(input);
\r
964 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:253:7: {...}? => ID ( resource )+ INDENT resourceDefinitions DEDENT
\r
966 if ( !((input.LT(1).getText().equals("template"))) ) {
\r
967 if (state.backtracking>0) {state.failed=true; return retval;}
\r
968 throw new FailedPredicateException(input, "template", "input.LT(1).getText().equals(\"template\")");
\r
970 ID24=(Token)match(input,ID,FOLLOW_ID_in_template1533); if (state.failed) return retval;
\r
971 if ( state.backtracking==0 ) stream_ID.add(ID24);
\r
973 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:254:10: ( resource )+
\r
978 int LA10_0 = input.LA(1);
\r
980 if ( (LA10_0==ID||LA10_0==LPAREN||LA10_0==LBRACKET||LA10_0==LCURLY||LA10_0==INT||LA10_0==FLOAT||(LA10_0>=STRING && LA10_0<=URI)||(LA10_0>=75 && LA10_0<=76)||(LA10_0>=79 && LA10_0<=80)) ) {
\r
987 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:254:10: resource
\r
989 pushFollow(FOLLOW_resource_in_template1535);
\r
990 resource25=resource();
\r
993 if (state.failed) return retval;
\r
994 if ( state.backtracking==0 ) stream_resource.add(resource25.getTree());
\r
1000 if ( cnt10 >= 1 ) break loop10;
\r
1001 if (state.backtracking>0) {state.failed=true; return retval;}
\r
1002 EarlyExitException eee =
\r
1003 new EarlyExitException(10, input);
\r
1009 INDENT26=(Token)match(input,INDENT,FOLLOW_INDENT_in_template1545); if (state.failed) return retval;
\r
1010 if ( state.backtracking==0 ) stream_INDENT.add(INDENT26);
\r
1012 pushFollow(FOLLOW_resourceDefinitions_in_template1547);
\r
1013 resourceDefinitions27=resourceDefinitions();
\r
1016 if (state.failed) return retval;
\r
1017 if ( state.backtracking==0 ) stream_resourceDefinitions.add(resourceDefinitions27.getTree());
\r
1018 DEDENT28=(Token)match(input,DEDENT,FOLLOW_DEDENT_in_template1549); if (state.failed) return retval;
\r
1019 if ( state.backtracking==0 ) stream_DEDENT.add(DEDENT28);
\r
1024 // elements: resourceDefinitions, resource
\r
1026 // rule labels: retval
\r
1027 // token list labels:
\r
1028 // rule list labels:
\r
1029 // wildcard labels:
\r
1030 if ( state.backtracking==0 ) {
\r
1031 retval.tree = root_0;
\r
1032 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1034 root_0 = (CommonTree)adaptor.nil();
\r
1035 // 256:7: -> ^( TEMPLATE_DEFINITION ( resource )+ resourceDefinitions )
\r
1037 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:256:10: ^( TEMPLATE_DEFINITION ( resource )+ resourceDefinitions )
\r
1039 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
1040 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TEMPLATE_DEFINITION, "TEMPLATE_DEFINITION"), root_1);
\r
1042 if ( !(stream_resource.hasNext()) ) {
\r
1043 throw new RewriteEarlyExitException();
\r
1045 while ( stream_resource.hasNext() ) {
\r
1046 adaptor.addChild(root_1, stream_resource.nextTree());
\r
1049 stream_resource.reset();
\r
1050 adaptor.addChild(root_1, stream_resourceDefinitions.nextTree());
\r
1052 adaptor.addChild(root_0, root_1);
\r
1057 retval.tree = root_0;}
\r
1061 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:257:7: ( resource )+ ( INDENT resourceDefinitions DEDENT )?
\r
1063 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:257:7: ( resource )+
\r
1068 int LA11_0 = input.LA(1);
\r
1070 if ( (LA11_0==ID||LA11_0==LPAREN||LA11_0==LBRACKET||LA11_0==LCURLY||LA11_0==INT||LA11_0==FLOAT||(LA11_0>=STRING && LA11_0<=URI)||(LA11_0>=75 && LA11_0<=76)||(LA11_0>=79 && LA11_0<=80)) ) {
\r
1077 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:257:7: resource
\r
1079 pushFollow(FOLLOW_resource_in_template1574);
\r
1080 resource29=resource();
\r
1083 if (state.failed) return retval;
\r
1084 if ( state.backtracking==0 ) stream_resource.add(resource29.getTree());
\r
1090 if ( cnt11 >= 1 ) break loop11;
\r
1091 if (state.backtracking>0) {state.failed=true; return retval;}
\r
1092 EarlyExitException eee =
\r
1093 new EarlyExitException(11, input);
\r
1099 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:258:7: ( INDENT resourceDefinitions DEDENT )?
\r
1101 int LA12_0 = input.LA(1);
\r
1103 if ( (LA12_0==INDENT) ) {
\r
1108 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:258:8: INDENT resourceDefinitions DEDENT
\r
1110 INDENT30=(Token)match(input,INDENT,FOLLOW_INDENT_in_template1585); if (state.failed) return retval;
\r
1111 if ( state.backtracking==0 ) stream_INDENT.add(INDENT30);
\r
1113 pushFollow(FOLLOW_resourceDefinitions_in_template1587);
\r
1114 resourceDefinitions31=resourceDefinitions();
\r
1117 if (state.failed) return retval;
\r
1118 if ( state.backtracking==0 ) stream_resourceDefinitions.add(resourceDefinitions31.getTree());
\r
1119 DEDENT32=(Token)match(input,DEDENT,FOLLOW_DEDENT_in_template1589); if (state.failed) return retval;
\r
1120 if ( state.backtracking==0 ) stream_DEDENT.add(DEDENT32);
\r
1131 // elements: resource, resourceDefinitions
\r
1133 // rule labels: retval
\r
1134 // token list labels:
\r
1135 // rule list labels:
\r
1136 // wildcard labels:
\r
1137 if ( state.backtracking==0 ) {
\r
1138 retval.tree = root_0;
\r
1139 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1141 root_0 = (CommonTree)adaptor.nil();
\r
1142 // 259:7: -> ^( TEMPLATE_INSTANCE ( resource )+ ( resourceDefinitions )? )
\r
1144 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:259:10: ^( TEMPLATE_INSTANCE ( resource )+ ( resourceDefinitions )? )
\r
1146 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
1147 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TEMPLATE_INSTANCE, "TEMPLATE_INSTANCE"), root_1);
\r
1149 if ( !(stream_resource.hasNext()) ) {
\r
1150 throw new RewriteEarlyExitException();
\r
1152 while ( stream_resource.hasNext() ) {
\r
1153 adaptor.addChild(root_1, stream_resource.nextTree());
\r
1156 stream_resource.reset();
\r
1157 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:259:40: ( resourceDefinitions )?
\r
1158 if ( stream_resourceDefinitions.hasNext() ) {
\r
1159 adaptor.addChild(root_1, stream_resourceDefinitions.nextTree());
\r
1162 stream_resourceDefinitions.reset();
\r
1164 adaptor.addChild(root_0, root_1);
\r
1169 retval.tree = root_0;}
\r
1178 retval.stop = input.LT(-1);
\r
1180 if ( state.backtracking==0 ) {
\r
1182 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
1183 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
1186 catch (RecognitionException re) {
\r
1188 recover(input,re);
\r
1189 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
1196 // $ANTLR end "template"
\r
1198 public static class relation_return extends ParserRuleReturnScope {
\r
1200 public Object getTree() { return tree; }
\r
1203 // $ANTLR start "relation"
\r
1204 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:267:1: relation : ( ( ID -> ID ) ( '.' ID -> ^( REF $relation ID ) )* | URI | '<T' -> INHERITS | '<R' -> SUBRELATION_OF | '<--' -> HAS_DOMAIN | '-->' -> HAS_RANGE | '==>' -> REQUIRES_VALUE_TYPE | '>--' -> DOMAIN_OF | ':' -> INSTANCE_OF | '=' -> EQUALS | '%' ID -> ^( VARIABLE ID ) );
\r
1205 public final GraphParser.relation_return relation() throws RecognitionException {
\r
1206 GraphParser.relation_return retval = new GraphParser.relation_return();
\r
1207 retval.start = input.LT(1);
\r
1209 CommonTree root_0 = null;
\r
1212 Token char_literal34=null;
\r
1215 Token string_literal37=null;
\r
1216 Token string_literal38=null;
\r
1217 Token string_literal39=null;
\r
1218 Token string_literal40=null;
\r
1219 Token string_literal41=null;
\r
1220 Token string_literal42=null;
\r
1221 Token char_literal43=null;
\r
1222 Token char_literal44=null;
\r
1223 Token char_literal45=null;
\r
1226 CommonTree ID33_tree=null;
\r
1227 CommonTree char_literal34_tree=null;
\r
1228 CommonTree ID35_tree=null;
\r
1229 CommonTree URI36_tree=null;
\r
1230 CommonTree string_literal37_tree=null;
\r
1231 CommonTree string_literal38_tree=null;
\r
1232 CommonTree string_literal39_tree=null;
\r
1233 CommonTree string_literal40_tree=null;
\r
1234 CommonTree string_literal41_tree=null;
\r
1235 CommonTree string_literal42_tree=null;
\r
1236 CommonTree char_literal43_tree=null;
\r
1237 CommonTree char_literal44_tree=null;
\r
1238 CommonTree char_literal45_tree=null;
\r
1239 CommonTree ID46_tree=null;
\r
1240 RewriteRuleTokenStream stream_67=new RewriteRuleTokenStream(adaptor,"token 67");
\r
1241 RewriteRuleTokenStream stream_66=new RewriteRuleTokenStream(adaptor,"token 66");
\r
1242 RewriteRuleTokenStream stream_69=new RewriteRuleTokenStream(adaptor,"token 69");
\r
1243 RewriteRuleTokenStream stream_68=new RewriteRuleTokenStream(adaptor,"token 68");
\r
1244 RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
\r
1245 RewriteRuleTokenStream stream_70=new RewriteRuleTokenStream(adaptor,"token 70");
\r
1246 RewriteRuleTokenStream stream_71=new RewriteRuleTokenStream(adaptor,"token 71");
\r
1247 RewriteRuleTokenStream stream_72=new RewriteRuleTokenStream(adaptor,"token 72");
\r
1248 RewriteRuleTokenStream stream_73=new RewriteRuleTokenStream(adaptor,"token 73");
\r
1249 RewriteRuleTokenStream stream_74=new RewriteRuleTokenStream(adaptor,"token 74");
\r
1250 RewriteRuleTokenStream stream_75=new RewriteRuleTokenStream(adaptor,"token 75");
\r
1253 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:268:5: ( ( ID -> ID ) ( '.' ID -> ^( REF $relation ID ) )* | URI | '<T' -> INHERITS | '<R' -> SUBRELATION_OF | '<--' -> HAS_DOMAIN | '-->' -> HAS_RANGE | '==>' -> REQUIRES_VALUE_TYPE | '>--' -> DOMAIN_OF | ':' -> INSTANCE_OF | '=' -> EQUALS | '%' ID -> ^( VARIABLE ID ) )
\r
1255 switch ( input.LA(1) ) {
\r
1312 if (state.backtracking>0) {state.failed=true; return retval;}
\r
1313 NoViableAltException nvae =
\r
1314 new NoViableAltException("", 15, 0, input);
\r
1321 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:268:7: ( ID -> ID ) ( '.' ID -> ^( REF $relation ID ) )*
\r
1323 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:268:7: ( ID -> ID )
\r
1324 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:268:9: ID
\r
1326 ID33=(Token)match(input,ID,FOLLOW_ID_in_relation1643); if (state.failed) return retval;
\r
1327 if ( state.backtracking==0 ) stream_ID.add(ID33);
\r
1334 // rule labels: retval
\r
1335 // token list labels:
\r
1336 // rule list labels:
\r
1337 // wildcard labels:
\r
1338 if ( state.backtracking==0 ) {
\r
1339 retval.tree = root_0;
\r
1340 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1342 root_0 = (CommonTree)adaptor.nil();
\r
1345 adaptor.addChild(root_0, stream_ID.nextNode());
\r
1349 retval.tree = root_0;}
\r
1352 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:269:7: ( '.' ID -> ^( REF $relation ID ) )*
\r
1356 int LA14_0 = input.LA(1);
\r
1358 if ( (LA14_0==66) ) {
\r
1365 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:269:8: '.' ID
\r
1367 char_literal34=(Token)match(input,66,FOLLOW_66_in_relation1658); if (state.failed) return retval;
\r
1368 if ( state.backtracking==0 ) stream_66.add(char_literal34);
\r
1370 ID35=(Token)match(input,ID,FOLLOW_ID_in_relation1660); if (state.failed) return retval;
\r
1371 if ( state.backtracking==0 ) stream_ID.add(ID35);
\r
1376 // elements: ID, relation
\r
1378 // rule labels: retval
\r
1379 // token list labels:
\r
1380 // rule list labels:
\r
1381 // wildcard labels:
\r
1382 if ( state.backtracking==0 ) {
\r
1383 retval.tree = root_0;
\r
1384 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1386 root_0 = (CommonTree)adaptor.nil();
\r
1387 // 269:15: -> ^( REF $relation ID )
\r
1389 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:269:18: ^( REF $relation ID )
\r
1391 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
1392 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(REF, "REF"), root_1);
\r
1394 adaptor.addChild(root_1, stream_retval.nextTree());
\r
1395 adaptor.addChild(root_1, stream_ID.nextNode());
\r
1397 adaptor.addChild(root_0, root_1);
\r
1402 retval.tree = root_0;}
\r
1415 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:270:7: URI
\r
1417 root_0 = (CommonTree)adaptor.nil();
\r
1419 URI36=(Token)match(input,URI,FOLLOW_URI_in_relation1681); if (state.failed) return retval;
\r
1420 if ( state.backtracking==0 ) {
\r
1421 URI36_tree = (CommonTree)adaptor.create(URI36);
\r
1422 adaptor.addChild(root_0, URI36_tree);
\r
1428 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:271:7: '<T'
\r
1430 string_literal37=(Token)match(input,67,FOLLOW_67_in_relation1689); if (state.failed) return retval;
\r
1431 if ( state.backtracking==0 ) stream_67.add(string_literal37);
\r
1438 // rule labels: retval
\r
1439 // token list labels:
\r
1440 // rule list labels:
\r
1441 // wildcard labels:
\r
1442 if ( state.backtracking==0 ) {
\r
1443 retval.tree = root_0;
\r
1444 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1446 root_0 = (CommonTree)adaptor.nil();
\r
1447 // 271:12: -> INHERITS
\r
1449 adaptor.addChild(root_0, (CommonTree)adaptor.create(INHERITS, "INHERITS"));
\r
1453 retval.tree = root_0;}
\r
1457 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:272:7: '<R'
\r
1459 string_literal38=(Token)match(input,68,FOLLOW_68_in_relation1701); if (state.failed) return retval;
\r
1460 if ( state.backtracking==0 ) stream_68.add(string_literal38);
\r
1467 // rule labels: retval
\r
1468 // token list labels:
\r
1469 // rule list labels:
\r
1470 // wildcard labels:
\r
1471 if ( state.backtracking==0 ) {
\r
1472 retval.tree = root_0;
\r
1473 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1475 root_0 = (CommonTree)adaptor.nil();
\r
1476 // 272:12: -> SUBRELATION_OF
\r
1478 adaptor.addChild(root_0, (CommonTree)adaptor.create(SUBRELATION_OF, "SUBRELATION_OF"));
\r
1482 retval.tree = root_0;}
\r
1486 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:273:7: '<--'
\r
1488 string_literal39=(Token)match(input,69,FOLLOW_69_in_relation1713); if (state.failed) return retval;
\r
1489 if ( state.backtracking==0 ) stream_69.add(string_literal39);
\r
1496 // rule labels: retval
\r
1497 // token list labels:
\r
1498 // rule list labels:
\r
1499 // wildcard labels:
\r
1500 if ( state.backtracking==0 ) {
\r
1501 retval.tree = root_0;
\r
1502 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1504 root_0 = (CommonTree)adaptor.nil();
\r
1505 // 273:13: -> HAS_DOMAIN
\r
1507 adaptor.addChild(root_0, (CommonTree)adaptor.create(HAS_DOMAIN, "HAS_DOMAIN"));
\r
1511 retval.tree = root_0;}
\r
1515 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:274:7: '-->'
\r
1517 string_literal40=(Token)match(input,70,FOLLOW_70_in_relation1725); if (state.failed) return retval;
\r
1518 if ( state.backtracking==0 ) stream_70.add(string_literal40);
\r
1525 // rule labels: retval
\r
1526 // token list labels:
\r
1527 // rule list labels:
\r
1528 // wildcard labels:
\r
1529 if ( state.backtracking==0 ) {
\r
1530 retval.tree = root_0;
\r
1531 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1533 root_0 = (CommonTree)adaptor.nil();
\r
1534 // 274:13: -> HAS_RANGE
\r
1536 adaptor.addChild(root_0, (CommonTree)adaptor.create(HAS_RANGE, "HAS_RANGE"));
\r
1540 retval.tree = root_0;}
\r
1544 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:275:7: '==>'
\r
1546 string_literal41=(Token)match(input,71,FOLLOW_71_in_relation1737); if (state.failed) return retval;
\r
1547 if ( state.backtracking==0 ) stream_71.add(string_literal41);
\r
1554 // rule labels: retval
\r
1555 // token list labels:
\r
1556 // rule list labels:
\r
1557 // wildcard labels:
\r
1558 if ( state.backtracking==0 ) {
\r
1559 retval.tree = root_0;
\r
1560 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1562 root_0 = (CommonTree)adaptor.nil();
\r
1563 // 275:13: -> REQUIRES_VALUE_TYPE
\r
1565 adaptor.addChild(root_0, (CommonTree)adaptor.create(REQUIRES_VALUE_TYPE, "REQUIRES_VALUE_TYPE"));
\r
1569 retval.tree = root_0;}
\r
1573 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:276:7: '>--'
\r
1575 string_literal42=(Token)match(input,72,FOLLOW_72_in_relation1749); if (state.failed) return retval;
\r
1576 if ( state.backtracking==0 ) stream_72.add(string_literal42);
\r
1583 // rule labels: retval
\r
1584 // token list labels:
\r
1585 // rule list labels:
\r
1586 // wildcard labels:
\r
1587 if ( state.backtracking==0 ) {
\r
1588 retval.tree = root_0;
\r
1589 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1591 root_0 = (CommonTree)adaptor.nil();
\r
1592 // 276:13: -> DOMAIN_OF
\r
1594 adaptor.addChild(root_0, (CommonTree)adaptor.create(DOMAIN_OF, "DOMAIN_OF"));
\r
1598 retval.tree = root_0;}
\r
1602 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:277:7: ':'
\r
1604 char_literal43=(Token)match(input,73,FOLLOW_73_in_relation1765); if (state.failed) return retval;
\r
1605 if ( state.backtracking==0 ) stream_73.add(char_literal43);
\r
1612 // rule labels: retval
\r
1613 // token list labels:
\r
1614 // rule list labels:
\r
1615 // wildcard labels:
\r
1616 if ( state.backtracking==0 ) {
\r
1617 retval.tree = root_0;
\r
1618 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1620 root_0 = (CommonTree)adaptor.nil();
\r
1621 // 277:11: -> INSTANCE_OF
\r
1623 adaptor.addChild(root_0, (CommonTree)adaptor.create(INSTANCE_OF, "INSTANCE_OF"));
\r
1627 retval.tree = root_0;}
\r
1631 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:278:7: '='
\r
1633 char_literal44=(Token)match(input,74,FOLLOW_74_in_relation1777); if (state.failed) return retval;
\r
1634 if ( state.backtracking==0 ) stream_74.add(char_literal44);
\r
1641 // rule labels: retval
\r
1642 // token list labels:
\r
1643 // rule list labels:
\r
1644 // wildcard labels:
\r
1645 if ( state.backtracking==0 ) {
\r
1646 retval.tree = root_0;
\r
1647 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1649 root_0 = (CommonTree)adaptor.nil();
\r
1650 // 278:11: -> EQUALS
\r
1652 adaptor.addChild(root_0, (CommonTree)adaptor.create(EQUALS, "EQUALS"));
\r
1656 retval.tree = root_0;}
\r
1660 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:279:7: '%' ID
\r
1662 char_literal45=(Token)match(input,75,FOLLOW_75_in_relation1789); if (state.failed) return retval;
\r
1663 if ( state.backtracking==0 ) stream_75.add(char_literal45);
\r
1665 ID46=(Token)match(input,ID,FOLLOW_ID_in_relation1791); if (state.failed) return retval;
\r
1666 if ( state.backtracking==0 ) stream_ID.add(ID46);
\r
1673 // rule labels: retval
\r
1674 // token list labels:
\r
1675 // rule list labels:
\r
1676 // wildcard labels:
\r
1677 if ( state.backtracking==0 ) {
\r
1678 retval.tree = root_0;
\r
1679 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1681 root_0 = (CommonTree)adaptor.nil();
\r
1682 // 279:14: -> ^( VARIABLE ID )
\r
1684 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:279:17: ^( VARIABLE ID )
\r
1686 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
1687 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(VARIABLE, "VARIABLE"), root_1);
\r
1689 adaptor.addChild(root_1, stream_ID.nextNode());
\r
1691 adaptor.addChild(root_0, root_1);
\r
1696 retval.tree = root_0;}
\r
1701 retval.stop = input.LT(-1);
\r
1703 if ( state.backtracking==0 ) {
\r
1705 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
1706 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
1709 catch (RecognitionException re) {
\r
1711 recover(input,re);
\r
1712 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
1719 // $ANTLR end "relation"
\r
1721 public static class resource_return extends ParserRuleReturnScope {
\r
1723 public Object getTree() { return tree; }
\r
1726 // $ANTLR start "resource"
\r
1727 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:282:1: resource : ( ({...}? => ID -> ^( BLANK ID ) | ID -> ID ) ( '.' ( ID -> ^( REF $resource ID ) | STRING -> ^( REF $resource STRING ) ) )* | URI | simpleValue -> ^( EMBEDDED_VALUE simpleValue ) | '$' basicType -> ^( EMBEDDED_TYPE basicType ) | '%' ID -> ^( VARIABLE ID ) );
\r
1728 public final GraphParser.resource_return resource() throws RecognitionException {
\r
1729 GraphParser.resource_return retval = new GraphParser.resource_return();
\r
1730 retval.start = input.LT(1);
\r
1732 CommonTree root_0 = null;
\r
1736 Token char_literal49=null;
\r
1738 Token STRING51=null;
\r
1740 Token char_literal54=null;
\r
1741 Token char_literal56=null;
\r
1743 GraphParser.simpleValue_return simpleValue53 = null;
\r
1745 GraphParser.basicType_return basicType55 = null;
\r
1748 CommonTree ID47_tree=null;
\r
1749 CommonTree ID48_tree=null;
\r
1750 CommonTree char_literal49_tree=null;
\r
1751 CommonTree ID50_tree=null;
\r
1752 CommonTree STRING51_tree=null;
\r
1753 CommonTree URI52_tree=null;
\r
1754 CommonTree char_literal54_tree=null;
\r
1755 CommonTree char_literal56_tree=null;
\r
1756 CommonTree ID57_tree=null;
\r
1757 RewriteRuleTokenStream stream_66=new RewriteRuleTokenStream(adaptor,"token 66");
\r
1758 RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
\r
1759 RewriteRuleTokenStream stream_75=new RewriteRuleTokenStream(adaptor,"token 75");
\r
1760 RewriteRuleTokenStream stream_STRING=new RewriteRuleTokenStream(adaptor,"token STRING");
\r
1761 RewriteRuleTokenStream stream_76=new RewriteRuleTokenStream(adaptor,"token 76");
\r
1762 RewriteRuleSubtreeStream stream_basicType=new RewriteRuleSubtreeStream(adaptor,"rule basicType");
\r
1763 RewriteRuleSubtreeStream stream_simpleValue=new RewriteRuleSubtreeStream(adaptor,"rule simpleValue");
\r
1765 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:283:5: ( ({...}? => ID -> ^( BLANK ID ) | ID -> ID ) ( '.' ( ID -> ^( REF $resource ID ) | STRING -> ^( REF $resource STRING ) ) )* | URI | simpleValue -> ^( EMBEDDED_VALUE simpleValue ) | '$' basicType -> ^( EMBEDDED_TYPE basicType ) | '%' ID -> ^( VARIABLE ID ) )
\r
1767 switch ( input.LA(1) ) {
\r
1801 if (state.backtracking>0) {state.failed=true; return retval;}
\r
1802 NoViableAltException nvae =
\r
1803 new NoViableAltException("", 19, 0, input);
\r
1810 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:283:7: ({...}? => ID -> ^( BLANK ID ) | ID -> ID ) ( '.' ( ID -> ^( REF $resource ID ) | STRING -> ^( REF $resource STRING ) ) )*
\r
1812 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:283:7: ({...}? => ID -> ^( BLANK ID ) | ID -> ID )
\r
1814 int LA16_0 = input.LA(1);
\r
1816 if ( (LA16_0==ID) ) {
\r
1817 int LA16_1 = input.LA(2);
\r
1819 if ( ((input.LT(1).getText().equals("_"))) ) {
\r
1822 else if ( (true) ) {
\r
1826 if (state.backtracking>0) {state.failed=true; return retval;}
\r
1827 NoViableAltException nvae =
\r
1828 new NoViableAltException("", 16, 1, input);
\r
1834 if (state.backtracking>0) {state.failed=true; return retval;}
\r
1835 NoViableAltException nvae =
\r
1836 new NoViableAltException("", 16, 0, input);
\r
1842 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:283:9: {...}? => ID
\r
1844 if ( !((input.LT(1).getText().equals("_"))) ) {
\r
1845 if (state.backtracking>0) {state.failed=true; return retval;}
\r
1846 throw new FailedPredicateException(input, "resource", "input.LT(1).getText().equals(\"_\")");
\r
1848 ID47=(Token)match(input,ID,FOLLOW_ID_in_resource1821); if (state.failed) return retval;
\r
1849 if ( state.backtracking==0 ) stream_ID.add(ID47);
\r
1856 // rule labels: retval
\r
1857 // token list labels:
\r
1858 // rule list labels:
\r
1859 // wildcard labels:
\r
1860 if ( state.backtracking==0 ) {
\r
1861 retval.tree = root_0;
\r
1862 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1864 root_0 = (CommonTree)adaptor.nil();
\r
1865 // 283:51: -> ^( BLANK ID )
\r
1867 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:283:54: ^( BLANK ID )
\r
1869 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
1870 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(BLANK, "BLANK"), root_1);
\r
1872 adaptor.addChild(root_1, stream_ID.nextNode());
\r
1874 adaptor.addChild(root_0, root_1);
\r
1879 retval.tree = root_0;}
\r
1883 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:284:9: ID
\r
1885 ID48=(Token)match(input,ID,FOLLOW_ID_in_resource1840); if (state.failed) return retval;
\r
1886 if ( state.backtracking==0 ) stream_ID.add(ID48);
\r
1893 // rule labels: retval
\r
1894 // token list labels:
\r
1895 // rule list labels:
\r
1896 // wildcard labels:
\r
1897 if ( state.backtracking==0 ) {
\r
1898 retval.tree = root_0;
\r
1899 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1901 root_0 = (CommonTree)adaptor.nil();
\r
1904 adaptor.addChild(root_0, stream_ID.nextNode());
\r
1908 retval.tree = root_0;}
\r
1914 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:285:7: ( '.' ( ID -> ^( REF $resource ID ) | STRING -> ^( REF $resource STRING ) ) )*
\r
1918 int LA18_0 = input.LA(1);
\r
1920 if ( (LA18_0==66) ) {
\r
1927 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:285:8: '.' ( ID -> ^( REF $resource ID ) | STRING -> ^( REF $resource STRING ) )
\r
1929 char_literal49=(Token)match(input,66,FOLLOW_66_in_resource1855); if (state.failed) return retval;
\r
1930 if ( state.backtracking==0 ) stream_66.add(char_literal49);
\r
1932 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:285:12: ( ID -> ^( REF $resource ID ) | STRING -> ^( REF $resource STRING ) )
\r
1934 int LA17_0 = input.LA(1);
\r
1936 if ( (LA17_0==ID) ) {
\r
1939 else if ( (LA17_0==STRING) ) {
\r
1943 if (state.backtracking>0) {state.failed=true; return retval;}
\r
1944 NoViableAltException nvae =
\r
1945 new NoViableAltException("", 17, 0, input);
\r
1951 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:285:13: ID
\r
1953 ID50=(Token)match(input,ID,FOLLOW_ID_in_resource1858); if (state.failed) return retval;
\r
1954 if ( state.backtracking==0 ) stream_ID.add(ID50);
\r
1959 // elements: ID, resource
\r
1961 // rule labels: retval
\r
1962 // token list labels:
\r
1963 // rule list labels:
\r
1964 // wildcard labels:
\r
1965 if ( state.backtracking==0 ) {
\r
1966 retval.tree = root_0;
\r
1967 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1969 root_0 = (CommonTree)adaptor.nil();
\r
1970 // 285:16: -> ^( REF $resource ID )
\r
1972 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:285:19: ^( REF $resource ID )
\r
1974 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
1975 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(REF, "REF"), root_1);
\r
1977 adaptor.addChild(root_1, stream_retval.nextTree());
\r
1978 adaptor.addChild(root_1, stream_ID.nextNode());
\r
1980 adaptor.addChild(root_0, root_1);
\r
1985 retval.tree = root_0;}
\r
1989 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:286:13: STRING
\r
1991 STRING51=(Token)match(input,STRING,FOLLOW_STRING_in_resource1883); if (state.failed) return retval;
\r
1992 if ( state.backtracking==0 ) stream_STRING.add(STRING51);
\r
1997 // elements: STRING, resource
\r
1999 // rule labels: retval
\r
2000 // token list labels:
\r
2001 // rule list labels:
\r
2002 // wildcard labels:
\r
2003 if ( state.backtracking==0 ) {
\r
2004 retval.tree = root_0;
\r
2005 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
2007 root_0 = (CommonTree)adaptor.nil();
\r
2008 // 286:20: -> ^( REF $resource STRING )
\r
2010 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:286:23: ^( REF $resource STRING )
\r
2012 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
2013 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(REF, "REF"), root_1);
\r
2015 adaptor.addChild(root_1, stream_retval.nextTree());
\r
2016 adaptor.addChild(root_1, stream_STRING.nextNode());
\r
2018 adaptor.addChild(root_0, root_1);
\r
2023 retval.tree = root_0;}
\r
2042 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:289:7: URI
\r
2044 root_0 = (CommonTree)adaptor.nil();
\r
2046 URI52=(Token)match(input,URI,FOLLOW_URI_in_resource1924); if (state.failed) return retval;
\r
2047 if ( state.backtracking==0 ) {
\r
2048 URI52_tree = (CommonTree)adaptor.create(URI52);
\r
2049 adaptor.addChild(root_0, URI52_tree);
\r
2055 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:290:7: simpleValue
\r
2057 pushFollow(FOLLOW_simpleValue_in_resource1932);
\r
2058 simpleValue53=simpleValue();
\r
2061 if (state.failed) return retval;
\r
2062 if ( state.backtracking==0 ) stream_simpleValue.add(simpleValue53.getTree());
\r
2066 // elements: simpleValue
\r
2068 // rule labels: retval
\r
2069 // token list labels:
\r
2070 // rule list labels:
\r
2071 // wildcard labels:
\r
2072 if ( state.backtracking==0 ) {
\r
2073 retval.tree = root_0;
\r
2074 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
2076 root_0 = (CommonTree)adaptor.nil();
\r
2077 // 290:19: -> ^( EMBEDDED_VALUE simpleValue )
\r
2079 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:290:22: ^( EMBEDDED_VALUE simpleValue )
\r
2081 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
2082 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(EMBEDDED_VALUE, "EMBEDDED_VALUE"), root_1);
\r
2084 adaptor.addChild(root_1, stream_simpleValue.nextTree());
\r
2086 adaptor.addChild(root_0, root_1);
\r
2091 retval.tree = root_0;}
\r
2095 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:291:7: '$' basicType
\r
2097 char_literal54=(Token)match(input,76,FOLLOW_76_in_resource1948); if (state.failed) return retval;
\r
2098 if ( state.backtracking==0 ) stream_76.add(char_literal54);
\r
2100 pushFollow(FOLLOW_basicType_in_resource1950);
\r
2101 basicType55=basicType();
\r
2104 if (state.failed) return retval;
\r
2105 if ( state.backtracking==0 ) stream_basicType.add(basicType55.getTree());
\r
2109 // elements: basicType
\r
2111 // rule labels: retval
\r
2112 // token list labels:
\r
2113 // rule list labels:
\r
2114 // wildcard labels:
\r
2115 if ( state.backtracking==0 ) {
\r
2116 retval.tree = root_0;
\r
2117 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
2119 root_0 = (CommonTree)adaptor.nil();
\r
2120 // 291:21: -> ^( EMBEDDED_TYPE basicType )
\r
2122 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:291:24: ^( EMBEDDED_TYPE basicType )
\r
2124 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
2125 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(EMBEDDED_TYPE, "EMBEDDED_TYPE"), root_1);
\r
2127 adaptor.addChild(root_1, stream_basicType.nextTree());
\r
2129 adaptor.addChild(root_0, root_1);
\r
2134 retval.tree = root_0;}
\r
2138 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:292:7: '%' ID
\r
2140 char_literal56=(Token)match(input,75,FOLLOW_75_in_resource1966); if (state.failed) return retval;
\r
2141 if ( state.backtracking==0 ) stream_75.add(char_literal56);
\r
2143 ID57=(Token)match(input,ID,FOLLOW_ID_in_resource1968); if (state.failed) return retval;
\r
2144 if ( state.backtracking==0 ) stream_ID.add(ID57);
\r
2151 // rule labels: retval
\r
2152 // token list labels:
\r
2153 // rule list labels:
\r
2154 // wildcard labels:
\r
2155 if ( state.backtracking==0 ) {
\r
2156 retval.tree = root_0;
\r
2157 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
2159 root_0 = (CommonTree)adaptor.nil();
\r
2160 // 292:14: -> ^( VARIABLE ID )
\r
2162 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:292:17: ^( VARIABLE ID )
\r
2164 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
2165 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(VARIABLE, "VARIABLE"), root_1);
\r
2167 adaptor.addChild(root_1, stream_ID.nextNode());
\r
2169 adaptor.addChild(root_0, root_1);
\r
2174 retval.tree = root_0;}
\r
2179 retval.stop = input.LT(-1);
\r
2181 if ( state.backtracking==0 ) {
\r
2183 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
2184 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
2187 catch (RecognitionException re) {
\r
2189 recover(input,re);
\r
2190 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
2197 // $ANTLR end "resource"
\r
2199 public static class type_return extends ParserRuleReturnScope {
\r
2201 public Object getTree() { return tree; }
\r
2204 // $ANTLR start "type"
\r
2205 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:306:1: type : ( arrayType | unionType );
\r
2206 public final GraphParser.type_return type() throws RecognitionException {
\r
2207 GraphParser.type_return retval = new GraphParser.type_return();
\r
2208 retval.start = input.LT(1);
\r
2210 CommonTree root_0 = null;
\r
2212 GraphParser.arrayType_return arrayType58 = null;
\r
2214 GraphParser.unionType_return unionType59 = null;
\r
2219 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:307:5: ( arrayType | unionType )
\r
2221 int LA20_0 = input.LA(1);
\r
2223 if ( (LA20_0==ID||LA20_0==LPAREN||LA20_0==LCURLY) ) {
\r
2226 else if ( (LA20_0==77) ) {
\r
2230 if (state.backtracking>0) {state.failed=true; return retval;}
\r
2231 NoViableAltException nvae =
\r
2232 new NoViableAltException("", 20, 0, input);
\r
2238 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:307:7: arrayType
\r
2240 root_0 = (CommonTree)adaptor.nil();
\r
2242 pushFollow(FOLLOW_arrayType_in_type2004);
\r
2243 arrayType58=arrayType();
\r
2246 if (state.failed) return retval;
\r
2247 if ( state.backtracking==0 ) adaptor.addChild(root_0, arrayType58.getTree());
\r
2252 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:308:7: unionType
\r
2254 root_0 = (CommonTree)adaptor.nil();
\r
2256 pushFollow(FOLLOW_unionType_in_type2012);
\r
2257 unionType59=unionType();
\r
2260 if (state.failed) return retval;
\r
2261 if ( state.backtracking==0 ) adaptor.addChild(root_0, unionType59.getTree());
\r
2267 retval.stop = input.LT(-1);
\r
2269 if ( state.backtracking==0 ) {
\r
2271 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
2272 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
2275 catch (RecognitionException re) {
\r
2277 recover(input,re);
\r
2278 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
2285 // $ANTLR end "type"
\r
2287 public static class unionType_return extends ParserRuleReturnScope {
\r
2289 public Object getTree() { return tree; }
\r
2292 // $ANTLR start "unionType"
\r
2293 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:311:1: unionType : ( '|' unionComponent )+ -> ^( UNION_TYPE ( unionComponent )+ ) ;
\r
2294 public final GraphParser.unionType_return unionType() throws RecognitionException {
\r
2295 GraphParser.unionType_return retval = new GraphParser.unionType_return();
\r
2296 retval.start = input.LT(1);
\r
2298 CommonTree root_0 = null;
\r
2300 Token char_literal60=null;
\r
2301 GraphParser.unionComponent_return unionComponent61 = null;
\r
2304 CommonTree char_literal60_tree=null;
\r
2305 RewriteRuleTokenStream stream_77=new RewriteRuleTokenStream(adaptor,"token 77");
\r
2306 RewriteRuleSubtreeStream stream_unionComponent=new RewriteRuleSubtreeStream(adaptor,"rule unionComponent");
\r
2308 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:312:5: ( ( '|' unionComponent )+ -> ^( UNION_TYPE ( unionComponent )+ ) )
\r
2309 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:313:6: ( '|' unionComponent )+
\r
2311 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:313:6: ( '|' unionComponent )+
\r
2316 int LA21_0 = input.LA(1);
\r
2318 if ( (LA21_0==77) ) {
\r
2325 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:313:7: '|' unionComponent
\r
2327 char_literal60=(Token)match(input,77,FOLLOW_77_in_unionType2041); if (state.failed) return retval;
\r
2328 if ( state.backtracking==0 ) stream_77.add(char_literal60);
\r
2330 pushFollow(FOLLOW_unionComponent_in_unionType2043);
\r
2331 unionComponent61=unionComponent();
\r
2334 if (state.failed) return retval;
\r
2335 if ( state.backtracking==0 ) stream_unionComponent.add(unionComponent61.getTree());
\r
2341 if ( cnt21 >= 1 ) break loop21;
\r
2342 if (state.backtracking>0) {state.failed=true; return retval;}
\r
2343 EarlyExitException eee =
\r
2344 new EarlyExitException(21, input);
\r
2353 // elements: unionComponent
\r
2355 // rule labels: retval
\r
2356 // token list labels:
\r
2357 // rule list labels:
\r
2358 // wildcard labels:
\r
2359 if ( state.backtracking==0 ) {
\r
2360 retval.tree = root_0;
\r
2361 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
2363 root_0 = (CommonTree)adaptor.nil();
\r
2364 // 314:5: -> ^( UNION_TYPE ( unionComponent )+ )
\r
2366 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:314:8: ^( UNION_TYPE ( unionComponent )+ )
\r
2368 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
2369 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(UNION_TYPE, "UNION_TYPE"), root_1);
\r
2371 if ( !(stream_unionComponent.hasNext()) ) {
\r
2372 throw new RewriteEarlyExitException();
\r
2374 while ( stream_unionComponent.hasNext() ) {
\r
2375 adaptor.addChild(root_1, stream_unionComponent.nextTree());
\r
2378 stream_unionComponent.reset();
\r
2380 adaptor.addChild(root_0, root_1);
\r
2385 retval.tree = root_0;}
\r
2388 retval.stop = input.LT(-1);
\r
2390 if ( state.backtracking==0 ) {
\r
2392 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
2393 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
2396 catch (RecognitionException re) {
\r
2398 recover(input,re);
\r
2399 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
2406 // $ANTLR end "unionType"
\r
2408 public static class unionComponent_return extends ParserRuleReturnScope {
\r
2410 public Object getTree() { return tree; }
\r
2413 // $ANTLR start "unionComponent"
\r
2414 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:317:1: unionComponent : ID ( ( arrayType )=> arrayType )? -> ^( TYPE_COMPONENT ID ( arrayType )? ) ;
\r
2415 public final GraphParser.unionComponent_return unionComponent() throws RecognitionException {
\r
2416 GraphParser.unionComponent_return retval = new GraphParser.unionComponent_return();
\r
2417 retval.start = input.LT(1);
\r
2419 CommonTree root_0 = null;
\r
2422 GraphParser.arrayType_return arrayType63 = null;
\r
2425 CommonTree ID62_tree=null;
\r
2426 RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
\r
2427 RewriteRuleSubtreeStream stream_arrayType=new RewriteRuleSubtreeStream(adaptor,"rule arrayType");
\r
2429 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:317:16: ( ID ( ( arrayType )=> arrayType )? -> ^( TYPE_COMPONENT ID ( arrayType )? ) )
\r
2430 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:317:18: ID ( ( arrayType )=> arrayType )?
\r
2432 ID62=(Token)match(input,ID,FOLLOW_ID_in_unionComponent2071); if (state.failed) return retval;
\r
2433 if ( state.backtracking==0 ) stream_ID.add(ID62);
\r
2435 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:317:21: ( ( arrayType )=> arrayType )?
\r
2437 alt22 = dfa22.predict(input);
\r
2440 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:317:22: ( arrayType )=> arrayType
\r
2442 pushFollow(FOLLOW_arrayType_in_unionComponent2080);
\r
2443 arrayType63=arrayType();
\r
2446 if (state.failed) return retval;
\r
2447 if ( state.backtracking==0 ) stream_arrayType.add(arrayType63.getTree());
\r
2457 // elements: ID, arrayType
\r
2459 // rule labels: retval
\r
2460 // token list labels:
\r
2461 // rule list labels:
\r
2462 // wildcard labels:
\r
2463 if ( state.backtracking==0 ) {
\r
2464 retval.tree = root_0;
\r
2465 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
2467 root_0 = (CommonTree)adaptor.nil();
\r
2468 // 317:49: -> ^( TYPE_COMPONENT ID ( arrayType )? )
\r
2470 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:317:52: ^( TYPE_COMPONENT ID ( arrayType )? )
\r
2472 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
2473 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPE_COMPONENT, "TYPE_COMPONENT"), root_1);
\r
2475 adaptor.addChild(root_1, stream_ID.nextNode());
\r
2476 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:317:72: ( arrayType )?
\r
2477 if ( stream_arrayType.hasNext() ) {
\r
2478 adaptor.addChild(root_1, stream_arrayType.nextTree());
\r
2481 stream_arrayType.reset();
\r
2483 adaptor.addChild(root_0, root_1);
\r
2488 retval.tree = root_0;}
\r
2491 retval.stop = input.LT(-1);
\r
2493 if ( state.backtracking==0 ) {
\r
2495 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
2496 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
2499 catch (RecognitionException re) {
\r
2501 recover(input,re);
\r
2502 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
2509 // $ANTLR end "unionComponent"
\r
2511 public static class arrayType_return extends ParserRuleReturnScope {
\r
2513 public Object getTree() { return tree; }
\r
2516 // $ANTLR start "arrayType"
\r
2517 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:319:1: arrayType : ( basicType -> basicType ) ( LBRACKET ( arrayLength )? RBRACKET -> ^( ARRAY_TYPE $arrayType ( arrayLength )? ) )* ;
\r
2518 public final GraphParser.arrayType_return arrayType() throws RecognitionException {
\r
2519 GraphParser.arrayType_return retval = new GraphParser.arrayType_return();
\r
2520 retval.start = input.LT(1);
\r
2522 CommonTree root_0 = null;
\r
2524 Token LBRACKET65=null;
\r
2525 Token RBRACKET67=null;
\r
2526 GraphParser.basicType_return basicType64 = null;
\r
2528 GraphParser.arrayLength_return arrayLength66 = null;
\r
2531 CommonTree LBRACKET65_tree=null;
\r
2532 CommonTree RBRACKET67_tree=null;
\r
2533 RewriteRuleTokenStream stream_LBRACKET=new RewriteRuleTokenStream(adaptor,"token LBRACKET");
\r
2534 RewriteRuleTokenStream stream_RBRACKET=new RewriteRuleTokenStream(adaptor,"token RBRACKET");
\r
2535 RewriteRuleSubtreeStream stream_arrayLength=new RewriteRuleSubtreeStream(adaptor,"rule arrayLength");
\r
2536 RewriteRuleSubtreeStream stream_basicType=new RewriteRuleSubtreeStream(adaptor,"rule basicType");
\r
2538 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:320:5: ( ( basicType -> basicType ) ( LBRACKET ( arrayLength )? RBRACKET -> ^( ARRAY_TYPE $arrayType ( arrayLength )? ) )* )
\r
2539 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:320:7: ( basicType -> basicType ) ( LBRACKET ( arrayLength )? RBRACKET -> ^( ARRAY_TYPE $arrayType ( arrayLength )? ) )*
\r
2541 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:320:7: ( basicType -> basicType )
\r
2542 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:320:8: basicType
\r
2544 pushFollow(FOLLOW_basicType_in_arrayType2108);
\r
2545 basicType64=basicType();
\r
2548 if (state.failed) return retval;
\r
2549 if ( state.backtracking==0 ) stream_basicType.add(basicType64.getTree());
\r
2553 // elements: basicType
\r
2555 // rule labels: retval
\r
2556 // token list labels:
\r
2557 // rule list labels:
\r
2558 // wildcard labels:
\r
2559 if ( state.backtracking==0 ) {
\r
2560 retval.tree = root_0;
\r
2561 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
2563 root_0 = (CommonTree)adaptor.nil();
\r
2564 // 320:18: -> basicType
\r
2566 adaptor.addChild(root_0, stream_basicType.nextTree());
\r
2570 retval.tree = root_0;}
\r
2573 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:321:7: ( LBRACKET ( arrayLength )? RBRACKET -> ^( ARRAY_TYPE $arrayType ( arrayLength )? ) )*
\r
2577 int LA24_0 = input.LA(1);
\r
2579 if ( (LA24_0==LBRACKET) ) {
\r
2586 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:321:8: LBRACKET ( arrayLength )? RBRACKET
\r
2588 LBRACKET65=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayType2122); if (state.failed) return retval;
\r
2589 if ( state.backtracking==0 ) stream_LBRACKET.add(LBRACKET65);
\r
2591 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:321:17: ( arrayLength )?
\r
2593 int LA23_0 = input.LA(1);
\r
2595 if ( ((LA23_0>=INT && LA23_0<=INT_RANGE)) ) {
\r
2600 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:321:17: arrayLength
\r
2602 pushFollow(FOLLOW_arrayLength_in_arrayType2124);
\r
2603 arrayLength66=arrayLength();
\r
2606 if (state.failed) return retval;
\r
2607 if ( state.backtracking==0 ) stream_arrayLength.add(arrayLength66.getTree());
\r
2614 RBRACKET67=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayType2127); if (state.failed) return retval;
\r
2615 if ( state.backtracking==0 ) stream_RBRACKET.add(RBRACKET67);
\r
2620 // elements: arrayType, arrayLength
\r
2622 // rule labels: retval
\r
2623 // token list labels:
\r
2624 // rule list labels:
\r
2625 // wildcard labels:
\r
2626 if ( state.backtracking==0 ) {
\r
2627 retval.tree = root_0;
\r
2628 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
2630 root_0 = (CommonTree)adaptor.nil();
\r
2631 // 321:39: -> ^( ARRAY_TYPE $arrayType ( arrayLength )? )
\r
2633 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:321:42: ^( ARRAY_TYPE $arrayType ( arrayLength )? )
\r
2635 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
2636 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ARRAY_TYPE, "ARRAY_TYPE"), root_1);
\r
2638 adaptor.addChild(root_1, stream_retval.nextTree());
\r
2639 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:321:66: ( arrayLength )?
\r
2640 if ( stream_arrayLength.hasNext() ) {
\r
2641 adaptor.addChild(root_1, stream_arrayLength.nextTree());
\r
2644 stream_arrayLength.reset();
\r
2646 adaptor.addChild(root_0, root_1);
\r
2651 retval.tree = root_0;}
\r
2663 retval.stop = input.LT(-1);
\r
2665 if ( state.backtracking==0 ) {
\r
2667 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
2668 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
2671 catch (RecognitionException re) {
\r
2673 recover(input,re);
\r
2674 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
2681 // $ANTLR end "arrayType"
\r
2683 public static class arrayLength_return extends ParserRuleReturnScope {
\r
2685 public Object getTree() { return tree; }
\r
2688 // $ANTLR start "arrayLength"
\r
2689 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:323:1: arrayLength : ( INT | INT_RANGE );
\r
2690 public final GraphParser.arrayLength_return arrayLength() throws RecognitionException {
\r
2691 GraphParser.arrayLength_return retval = new GraphParser.arrayLength_return();
\r
2692 retval.start = input.LT(1);
\r
2694 CommonTree root_0 = null;
\r
2698 CommonTree set68_tree=null;
\r
2701 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:324:5: ( INT | INT_RANGE )
\r
2702 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:
\r
2704 root_0 = (CommonTree)adaptor.nil();
\r
2706 set68=(Token)input.LT(1);
\r
2707 if ( (input.LA(1)>=INT && input.LA(1)<=INT_RANGE) ) {
\r
2709 if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set68));
\r
2710 state.errorRecovery=false;state.failed=false;
\r
2713 if (state.backtracking>0) {state.failed=true; return retval;}
\r
2714 MismatchedSetException mse = new MismatchedSetException(null,input);
\r
2721 retval.stop = input.LT(-1);
\r
2723 if ( state.backtracking==0 ) {
\r
2725 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
2726 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
2729 catch (RecognitionException re) {
\r
2731 recover(input,re);
\r
2732 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
2739 // $ANTLR end "arrayLength"
\r
2741 public static class basicType_return extends ParserRuleReturnScope {
\r
2743 public Object getTree() { return tree; }
\r
2746 // $ANTLR start "basicType"
\r
2747 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:328:1: basicType : ( tupleType | recordType | typeReference );
\r
2748 public final GraphParser.basicType_return basicType() throws RecognitionException {
\r
2749 GraphParser.basicType_return retval = new GraphParser.basicType_return();
\r
2750 retval.start = input.LT(1);
\r
2752 CommonTree root_0 = null;
\r
2754 GraphParser.tupleType_return tupleType69 = null;
\r
2756 GraphParser.recordType_return recordType70 = null;
\r
2758 GraphParser.typeReference_return typeReference71 = null;
\r
2763 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:329:5: ( tupleType | recordType | typeReference )
\r
2765 switch ( input.LA(1) ) {
\r
2782 if (state.backtracking>0) {state.failed=true; return retval;}
\r
2783 NoViableAltException nvae =
\r
2784 new NoViableAltException("", 25, 0, input);
\r
2791 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:329:7: tupleType
\r
2793 root_0 = (CommonTree)adaptor.nil();
\r
2795 pushFollow(FOLLOW_tupleType_in_basicType2181);
\r
2796 tupleType69=tupleType();
\r
2799 if (state.failed) return retval;
\r
2800 if ( state.backtracking==0 ) adaptor.addChild(root_0, tupleType69.getTree());
\r
2805 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:330:7: recordType
\r
2807 root_0 = (CommonTree)adaptor.nil();
\r
2809 pushFollow(FOLLOW_recordType_in_basicType2189);
\r
2810 recordType70=recordType();
\r
2813 if (state.failed) return retval;
\r
2814 if ( state.backtracking==0 ) adaptor.addChild(root_0, recordType70.getTree());
\r
2819 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:331:7: typeReference
\r
2821 root_0 = (CommonTree)adaptor.nil();
\r
2823 pushFollow(FOLLOW_typeReference_in_basicType2197);
\r
2824 typeReference71=typeReference();
\r
2827 if (state.failed) return retval;
\r
2828 if ( state.backtracking==0 ) adaptor.addChild(root_0, typeReference71.getTree());
\r
2834 retval.stop = input.LT(-1);
\r
2836 if ( state.backtracking==0 ) {
\r
2838 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
2839 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
2842 catch (RecognitionException re) {
\r
2844 recover(input,re);
\r
2845 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
2852 // $ANTLR end "basicType"
\r
2854 public static class tupleType_return extends ParserRuleReturnScope {
\r
2856 public Object getTree() { return tree; }
\r
2859 // $ANTLR start "tupleType"
\r
2860 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:334:1: tupleType : LPAREN ( type ( ',' type )* )? RPAREN -> ^( TUPLE_TYPE ( type )* ) ;
\r
2861 public final GraphParser.tupleType_return tupleType() throws RecognitionException {
\r
2862 GraphParser.tupleType_return retval = new GraphParser.tupleType_return();
\r
2863 retval.start = input.LT(1);
\r
2865 CommonTree root_0 = null;
\r
2867 Token LPAREN72=null;
\r
2868 Token char_literal74=null;
\r
2869 Token RPAREN76=null;
\r
2870 GraphParser.type_return type73 = null;
\r
2872 GraphParser.type_return type75 = null;
\r
2875 CommonTree LPAREN72_tree=null;
\r
2876 CommonTree char_literal74_tree=null;
\r
2877 CommonTree RPAREN76_tree=null;
\r
2878 RewriteRuleTokenStream stream_78=new RewriteRuleTokenStream(adaptor,"token 78");
\r
2879 RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
\r
2880 RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
\r
2881 RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
\r
2883 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:335:5: ( LPAREN ( type ( ',' type )* )? RPAREN -> ^( TUPLE_TYPE ( type )* ) )
\r
2884 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:335:7: LPAREN ( type ( ',' type )* )? RPAREN
\r
2886 LPAREN72=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_tupleType2219); if (state.failed) return retval;
\r
2887 if ( state.backtracking==0 ) stream_LPAREN.add(LPAREN72);
\r
2889 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:335:14: ( type ( ',' type )* )?
\r
2891 int LA27_0 = input.LA(1);
\r
2893 if ( (LA27_0==ID||LA27_0==LPAREN||LA27_0==LCURLY||LA27_0==77) ) {
\r
2898 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:335:15: type ( ',' type )*
\r
2900 pushFollow(FOLLOW_type_in_tupleType2222);
\r
2904 if (state.failed) return retval;
\r
2905 if ( state.backtracking==0 ) stream_type.add(type73.getTree());
\r
2906 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:335:20: ( ',' type )*
\r
2910 int LA26_0 = input.LA(1);
\r
2912 if ( (LA26_0==78) ) {
\r
2919 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:335:21: ',' type
\r
2921 char_literal74=(Token)match(input,78,FOLLOW_78_in_tupleType2225); if (state.failed) return retval;
\r
2922 if ( state.backtracking==0 ) stream_78.add(char_literal74);
\r
2924 pushFollow(FOLLOW_type_in_tupleType2227);
\r
2928 if (state.failed) return retval;
\r
2929 if ( state.backtracking==0 ) stream_type.add(type75.getTree());
\r
2945 RPAREN76=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_tupleType2233); if (state.failed) return retval;
\r
2946 if ( state.backtracking==0 ) stream_RPAREN.add(RPAREN76);
\r
2953 // rule labels: retval
\r
2954 // token list labels:
\r
2955 // rule list labels:
\r
2956 // wildcard labels:
\r
2957 if ( state.backtracking==0 ) {
\r
2958 retval.tree = root_0;
\r
2959 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
2961 root_0 = (CommonTree)adaptor.nil();
\r
2962 // 336:5: -> ^( TUPLE_TYPE ( type )* )
\r
2964 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:336:8: ^( TUPLE_TYPE ( type )* )
\r
2966 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
2967 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TUPLE_TYPE, "TUPLE_TYPE"), root_1);
\r
2969 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:336:21: ( type )*
\r
2970 while ( stream_type.hasNext() ) {
\r
2971 adaptor.addChild(root_1, stream_type.nextTree());
\r
2974 stream_type.reset();
\r
2976 adaptor.addChild(root_0, root_1);
\r
2981 retval.tree = root_0;}
\r
2984 retval.stop = input.LT(-1);
\r
2986 if ( state.backtracking==0 ) {
\r
2988 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
2989 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
2992 catch (RecognitionException re) {
\r
2994 recover(input,re);
\r
2995 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
3002 // $ANTLR end "tupleType"
\r
3004 public static class recordType_return extends ParserRuleReturnScope {
\r
3006 public Object getTree() { return tree; }
\r
3009 // $ANTLR start "recordType"
\r
3010 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:339:1: recordType : LCURLY ( component ( ',' component )* )? RCURLY -> ^( RECORD_TYPE ( component )* ) ;
\r
3011 public final GraphParser.recordType_return recordType() throws RecognitionException {
\r
3012 GraphParser.recordType_return retval = new GraphParser.recordType_return();
\r
3013 retval.start = input.LT(1);
\r
3015 CommonTree root_0 = null;
\r
3017 Token LCURLY77=null;
\r
3018 Token char_literal79=null;
\r
3019 Token RCURLY81=null;
\r
3020 GraphParser.component_return component78 = null;
\r
3022 GraphParser.component_return component80 = null;
\r
3025 CommonTree LCURLY77_tree=null;
\r
3026 CommonTree char_literal79_tree=null;
\r
3027 CommonTree RCURLY81_tree=null;
\r
3028 RewriteRuleTokenStream stream_78=new RewriteRuleTokenStream(adaptor,"token 78");
\r
3029 RewriteRuleTokenStream stream_LCURLY=new RewriteRuleTokenStream(adaptor,"token LCURLY");
\r
3030 RewriteRuleTokenStream stream_RCURLY=new RewriteRuleTokenStream(adaptor,"token RCURLY");
\r
3031 RewriteRuleSubtreeStream stream_component=new RewriteRuleSubtreeStream(adaptor,"rule component");
\r
3033 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:340:5: ( LCURLY ( component ( ',' component )* )? RCURLY -> ^( RECORD_TYPE ( component )* ) )
\r
3034 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:340:7: LCURLY ( component ( ',' component )* )? RCURLY
\r
3036 LCURLY77=(Token)match(input,LCURLY,FOLLOW_LCURLY_in_recordType2266); if (state.failed) return retval;
\r
3037 if ( state.backtracking==0 ) stream_LCURLY.add(LCURLY77);
\r
3039 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:340:14: ( component ( ',' component )* )?
\r
3041 int LA29_0 = input.LA(1);
\r
3043 if ( (LA29_0==ID) ) {
\r
3048 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:340:15: component ( ',' component )*
\r
3050 pushFollow(FOLLOW_component_in_recordType2269);
\r
3051 component78=component();
\r
3054 if (state.failed) return retval;
\r
3055 if ( state.backtracking==0 ) stream_component.add(component78.getTree());
\r
3056 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:340:25: ( ',' component )*
\r
3060 int LA28_0 = input.LA(1);
\r
3062 if ( (LA28_0==78) ) {
\r
3069 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:340:26: ',' component
\r
3071 char_literal79=(Token)match(input,78,FOLLOW_78_in_recordType2272); if (state.failed) return retval;
\r
3072 if ( state.backtracking==0 ) stream_78.add(char_literal79);
\r
3074 pushFollow(FOLLOW_component_in_recordType2274);
\r
3075 component80=component();
\r
3078 if (state.failed) return retval;
\r
3079 if ( state.backtracking==0 ) stream_component.add(component80.getTree());
\r
3095 RCURLY81=(Token)match(input,RCURLY,FOLLOW_RCURLY_in_recordType2280); if (state.failed) return retval;
\r
3096 if ( state.backtracking==0 ) stream_RCURLY.add(RCURLY81);
\r
3101 // elements: component
\r
3103 // rule labels: retval
\r
3104 // token list labels:
\r
3105 // rule list labels:
\r
3106 // wildcard labels:
\r
3107 if ( state.backtracking==0 ) {
\r
3108 retval.tree = root_0;
\r
3109 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
3111 root_0 = (CommonTree)adaptor.nil();
\r
3112 // 341:5: -> ^( RECORD_TYPE ( component )* )
\r
3114 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:341:8: ^( RECORD_TYPE ( component )* )
\r
3116 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
3117 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(RECORD_TYPE, "RECORD_TYPE"), root_1);
\r
3119 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:341:22: ( component )*
\r
3120 while ( stream_component.hasNext() ) {
\r
3121 adaptor.addChild(root_1, stream_component.nextTree());
\r
3124 stream_component.reset();
\r
3126 adaptor.addChild(root_0, root_1);
\r
3131 retval.tree = root_0;}
\r
3134 retval.stop = input.LT(-1);
\r
3136 if ( state.backtracking==0 ) {
\r
3138 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
3139 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
3142 catch (RecognitionException re) {
\r
3144 recover(input,re);
\r
3145 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
3152 // $ANTLR end "recordType"
\r
3154 public static class component_return extends ParserRuleReturnScope {
\r
3156 public Object getTree() { return tree; }
\r
3159 // $ANTLR start "component"
\r
3160 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:344:1: component : ID ':' type -> ^( TYPE_COMPONENT ID type ) ;
\r
3161 public final GraphParser.component_return component() throws RecognitionException {
\r
3162 GraphParser.component_return retval = new GraphParser.component_return();
\r
3163 retval.start = input.LT(1);
\r
3165 CommonTree root_0 = null;
\r
3168 Token char_literal83=null;
\r
3169 GraphParser.type_return type84 = null;
\r
3172 CommonTree ID82_tree=null;
\r
3173 CommonTree char_literal83_tree=null;
\r
3174 RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
\r
3175 RewriteRuleTokenStream stream_73=new RewriteRuleTokenStream(adaptor,"token 73");
\r
3176 RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
\r
3178 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:345:5: ( ID ':' type -> ^( TYPE_COMPONENT ID type ) )
\r
3179 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:345:7: ID ':' type
\r
3181 ID82=(Token)match(input,ID,FOLLOW_ID_in_component2312); if (state.failed) return retval;
\r
3182 if ( state.backtracking==0 ) stream_ID.add(ID82);
\r
3184 char_literal83=(Token)match(input,73,FOLLOW_73_in_component2314); if (state.failed) return retval;
\r
3185 if ( state.backtracking==0 ) stream_73.add(char_literal83);
\r
3187 pushFollow(FOLLOW_type_in_component2316);
\r
3191 if (state.failed) return retval;
\r
3192 if ( state.backtracking==0 ) stream_type.add(type84.getTree());
\r
3196 // elements: type, ID
\r
3198 // rule labels: retval
\r
3199 // token list labels:
\r
3200 // rule list labels:
\r
3201 // wildcard labels:
\r
3202 if ( state.backtracking==0 ) {
\r
3203 retval.tree = root_0;
\r
3204 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
3206 root_0 = (CommonTree)adaptor.nil();
\r
3207 // 346:5: -> ^( TYPE_COMPONENT ID type )
\r
3209 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:346:8: ^( TYPE_COMPONENT ID type )
\r
3211 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
3212 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPE_COMPONENT, "TYPE_COMPONENT"), root_1);
\r
3214 adaptor.addChild(root_1, stream_ID.nextNode());
\r
3215 adaptor.addChild(root_1, stream_type.nextTree());
\r
3217 adaptor.addChild(root_0, root_1);
\r
3222 retval.tree = root_0;}
\r
3225 retval.stop = input.LT(-1);
\r
3227 if ( state.backtracking==0 ) {
\r
3229 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
3230 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
3233 catch (RecognitionException re) {
\r
3235 recover(input,re);
\r
3236 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
3243 // $ANTLR end "component"
\r
3245 public static class typeReference_return extends ParserRuleReturnScope {
\r
3247 public Object getTree() { return tree; }
\r
3250 // $ANTLR start "typeReference"
\r
3251 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:349:1: typeReference : ID ( ( LPAREN )=> LPAREN parameter ( ',' parameter )* RPAREN )? -> ^( TYPE_REFERENCE ID ( parameter )* ) ;
\r
3252 public final GraphParser.typeReference_return typeReference() throws RecognitionException {
\r
3253 GraphParser.typeReference_return retval = new GraphParser.typeReference_return();
\r
3254 retval.start = input.LT(1);
\r
3256 CommonTree root_0 = null;
\r
3259 Token LPAREN86=null;
\r
3260 Token char_literal88=null;
\r
3261 Token RPAREN90=null;
\r
3262 GraphParser.parameter_return parameter87 = null;
\r
3264 GraphParser.parameter_return parameter89 = null;
\r
3267 CommonTree ID85_tree=null;
\r
3268 CommonTree LPAREN86_tree=null;
\r
3269 CommonTree char_literal88_tree=null;
\r
3270 CommonTree RPAREN90_tree=null;
\r
3271 RewriteRuleTokenStream stream_78=new RewriteRuleTokenStream(adaptor,"token 78");
\r
3272 RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
\r
3273 RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
\r
3274 RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
\r
3275 RewriteRuleSubtreeStream stream_parameter=new RewriteRuleSubtreeStream(adaptor,"rule parameter");
\r
3277 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:350:5: ( ID ( ( LPAREN )=> LPAREN parameter ( ',' parameter )* RPAREN )? -> ^( TYPE_REFERENCE ID ( parameter )* ) )
\r
3278 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:350:7: ID ( ( LPAREN )=> LPAREN parameter ( ',' parameter )* RPAREN )?
\r
3280 ID85=(Token)match(input,ID,FOLLOW_ID_in_typeReference2350); if (state.failed) return retval;
\r
3281 if ( state.backtracking==0 ) stream_ID.add(ID85);
\r
3283 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:350:10: ( ( LPAREN )=> LPAREN parameter ( ',' parameter )* RPAREN )?
\r
3285 alt31 = dfa31.predict(input);
\r
3288 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:350:11: ( LPAREN )=> LPAREN parameter ( ',' parameter )* RPAREN
\r
3290 LPAREN86=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_typeReference2358); if (state.failed) return retval;
\r
3291 if ( state.backtracking==0 ) stream_LPAREN.add(LPAREN86);
\r
3293 pushFollow(FOLLOW_parameter_in_typeReference2360);
\r
3294 parameter87=parameter();
\r
3297 if (state.failed) return retval;
\r
3298 if ( state.backtracking==0 ) stream_parameter.add(parameter87.getTree());
\r
3299 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:350:39: ( ',' parameter )*
\r
3303 int LA30_0 = input.LA(1);
\r
3305 if ( (LA30_0==78) ) {
\r
3312 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:350:40: ',' parameter
\r
3314 char_literal88=(Token)match(input,78,FOLLOW_78_in_typeReference2363); if (state.failed) return retval;
\r
3315 if ( state.backtracking==0 ) stream_78.add(char_literal88);
\r
3317 pushFollow(FOLLOW_parameter_in_typeReference2365);
\r
3318 parameter89=parameter();
\r
3321 if (state.failed) return retval;
\r
3322 if ( state.backtracking==0 ) stream_parameter.add(parameter89.getTree());
\r
3332 RPAREN90=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_typeReference2369); if (state.failed) return retval;
\r
3333 if ( state.backtracking==0 ) stream_RPAREN.add(RPAREN90);
\r
3344 // elements: ID, parameter
\r
3346 // rule labels: retval
\r
3347 // token list labels:
\r
3348 // rule list labels:
\r
3349 // wildcard labels:
\r
3350 if ( state.backtracking==0 ) {
\r
3351 retval.tree = root_0;
\r
3352 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
3354 root_0 = (CommonTree)adaptor.nil();
\r
3355 // 351:5: -> ^( TYPE_REFERENCE ID ( parameter )* )
\r
3357 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:351:8: ^( TYPE_REFERENCE ID ( parameter )* )
\r
3359 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
3360 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPE_REFERENCE, "TYPE_REFERENCE"), root_1);
\r
3362 adaptor.addChild(root_1, stream_ID.nextNode());
\r
3363 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:351:28: ( parameter )*
\r
3364 while ( stream_parameter.hasNext() ) {
\r
3365 adaptor.addChild(root_1, stream_parameter.nextTree());
\r
3368 stream_parameter.reset();
\r
3370 adaptor.addChild(root_0, root_1);
\r
3375 retval.tree = root_0;}
\r
3378 retval.stop = input.LT(-1);
\r
3380 if ( state.backtracking==0 ) {
\r
3382 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
3383 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
3386 catch (RecognitionException re) {
\r
3388 recover(input,re);
\r
3389 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
3396 // $ANTLR end "typeReference"
\r
3398 public static class parameter_return extends ParserRuleReturnScope {
\r
3400 public Object getTree() { return tree; }
\r
3403 // $ANTLR start "parameter"
\r
3404 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:354:1: parameter : ( ID '=' parameterValue -> ^( TYPE_ANNOTATION ID parameterValue ) | type );
\r
3405 public final GraphParser.parameter_return parameter() throws RecognitionException {
\r
3406 GraphParser.parameter_return retval = new GraphParser.parameter_return();
\r
3407 retval.start = input.LT(1);
\r
3409 CommonTree root_0 = null;
\r
3412 Token char_literal92=null;
\r
3413 GraphParser.parameterValue_return parameterValue93 = null;
\r
3415 GraphParser.type_return type94 = null;
\r
3418 CommonTree ID91_tree=null;
\r
3419 CommonTree char_literal92_tree=null;
\r
3420 RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
\r
3421 RewriteRuleTokenStream stream_74=new RewriteRuleTokenStream(adaptor,"token 74");
\r
3422 RewriteRuleSubtreeStream stream_parameterValue=new RewriteRuleSubtreeStream(adaptor,"rule parameterValue");
\r
3424 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:355:5: ( ID '=' parameterValue -> ^( TYPE_ANNOTATION ID parameterValue ) | type )
\r
3426 int LA32_0 = input.LA(1);
\r
3428 if ( (LA32_0==ID) ) {
\r
3429 int LA32_1 = input.LA(2);
\r
3431 if ( (LA32_1==74) ) {
\r
3434 else if ( ((LA32_1>=LPAREN && LA32_1<=LBRACKET)||LA32_1==78) ) {
\r
3438 if (state.backtracking>0) {state.failed=true; return retval;}
\r
3439 NoViableAltException nvae =
\r
3440 new NoViableAltException("", 32, 1, input);
\r
3445 else if ( (LA32_0==LPAREN||LA32_0==LCURLY||LA32_0==77) ) {
\r
3449 if (state.backtracking>0) {state.failed=true; return retval;}
\r
3450 NoViableAltException nvae =
\r
3451 new NoViableAltException("", 32, 0, input);
\r
3457 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:355:7: ID '=' parameterValue
\r
3459 ID91=(Token)match(input,ID,FOLLOW_ID_in_parameter2405); if (state.failed) return retval;
\r
3460 if ( state.backtracking==0 ) stream_ID.add(ID91);
\r
3462 char_literal92=(Token)match(input,74,FOLLOW_74_in_parameter2407); if (state.failed) return retval;
\r
3463 if ( state.backtracking==0 ) stream_74.add(char_literal92);
\r
3465 pushFollow(FOLLOW_parameterValue_in_parameter2409);
\r
3466 parameterValue93=parameterValue();
\r
3469 if (state.failed) return retval;
\r
3470 if ( state.backtracking==0 ) stream_parameterValue.add(parameterValue93.getTree());
\r
3474 // elements: ID, parameterValue
\r
3476 // rule labels: retval
\r
3477 // token list labels:
\r
3478 // rule list labels:
\r
3479 // wildcard labels:
\r
3480 if ( state.backtracking==0 ) {
\r
3481 retval.tree = root_0;
\r
3482 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
3484 root_0 = (CommonTree)adaptor.nil();
\r
3485 // 355:29: -> ^( TYPE_ANNOTATION ID parameterValue )
\r
3487 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:355:32: ^( TYPE_ANNOTATION ID parameterValue )
\r
3489 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
3490 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPE_ANNOTATION, "TYPE_ANNOTATION"), root_1);
\r
3492 adaptor.addChild(root_1, stream_ID.nextNode());
\r
3493 adaptor.addChild(root_1, stream_parameterValue.nextTree());
\r
3495 adaptor.addChild(root_0, root_1);
\r
3500 retval.tree = root_0;}
\r
3504 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:356:7: type
\r
3506 root_0 = (CommonTree)adaptor.nil();
\r
3508 pushFollow(FOLLOW_type_in_parameter2427);
\r
3512 if (state.failed) return retval;
\r
3513 if ( state.backtracking==0 ) adaptor.addChild(root_0, type94.getTree());
\r
3519 retval.stop = input.LT(-1);
\r
3521 if ( state.backtracking==0 ) {
\r
3523 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
3524 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
3527 catch (RecognitionException re) {
\r
3529 recover(input,re);
\r
3530 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
3537 // $ANTLR end "parameter"
\r
3539 public static class parameterValue_return extends ParserRuleReturnScope {
\r
3541 public Object getTree() { return tree; }
\r
3544 // $ANTLR start "parameterValue"
\r
3545 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:359:1: parameterValue : ( string | boolean_ | number | rangePar -> ^( RANGE rangePar ) );
\r
3546 public final GraphParser.parameterValue_return parameterValue() throws RecognitionException {
\r
3547 GraphParser.parameterValue_return retval = new GraphParser.parameterValue_return();
\r
3548 retval.start = input.LT(1);
\r
3550 CommonTree root_0 = null;
\r
3552 GraphParser.string_return string95 = null;
\r
3554 GraphParser.boolean__return boolean_96 = null;
\r
3556 GraphParser.number_return number97 = null;
\r
3558 GraphParser.rangePar_return rangePar98 = null;
\r
3561 RewriteRuleSubtreeStream stream_rangePar=new RewriteRuleSubtreeStream(adaptor,"rule rangePar");
\r
3563 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:360:5: ( string | boolean_ | number | rangePar -> ^( RANGE rangePar ) )
\r
3565 switch ( input.LA(1) ) {
\r
3590 if (state.backtracking>0) {state.failed=true; return retval;}
\r
3591 NoViableAltException nvae =
\r
3592 new NoViableAltException("", 33, 0, input);
\r
3599 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:360:7: string
\r
3601 root_0 = (CommonTree)adaptor.nil();
\r
3603 pushFollow(FOLLOW_string_in_parameterValue2446);
\r
3604 string95=string();
\r
3607 if (state.failed) return retval;
\r
3608 if ( state.backtracking==0 ) adaptor.addChild(root_0, string95.getTree());
\r
3613 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:361:7: boolean_
\r
3615 root_0 = (CommonTree)adaptor.nil();
\r
3617 pushFollow(FOLLOW_boolean__in_parameterValue2454);
\r
3618 boolean_96=boolean_();
\r
3621 if (state.failed) return retval;
\r
3622 if ( state.backtracking==0 ) adaptor.addChild(root_0, boolean_96.getTree());
\r
3627 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:362:7: number
\r
3629 root_0 = (CommonTree)adaptor.nil();
\r
3631 pushFollow(FOLLOW_number_in_parameterValue2462);
\r
3632 number97=number();
\r
3635 if (state.failed) return retval;
\r
3636 if ( state.backtracking==0 ) adaptor.addChild(root_0, number97.getTree());
\r
3641 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:363:7: rangePar
\r
3643 pushFollow(FOLLOW_rangePar_in_parameterValue2470);
\r
3644 rangePar98=rangePar();
\r
3647 if (state.failed) return retval;
\r
3648 if ( state.backtracking==0 ) stream_rangePar.add(rangePar98.getTree());
\r
3652 // elements: rangePar
\r
3654 // rule labels: retval
\r
3655 // token list labels:
\r
3656 // rule list labels:
\r
3657 // wildcard labels:
\r
3658 if ( state.backtracking==0 ) {
\r
3659 retval.tree = root_0;
\r
3660 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
3662 root_0 = (CommonTree)adaptor.nil();
\r
3663 // 363:16: -> ^( RANGE rangePar )
\r
3665 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:363:19: ^( RANGE rangePar )
\r
3667 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
3668 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(RANGE, "RANGE"), root_1);
\r
3670 adaptor.addChild(root_1, stream_rangePar.nextTree());
\r
3672 adaptor.addChild(root_0, root_1);
\r
3677 retval.tree = root_0;}
\r
3682 retval.stop = input.LT(-1);
\r
3684 if ( state.backtracking==0 ) {
\r
3686 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
3687 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
3690 catch (RecognitionException re) {
\r
3692 recover(input,re);
\r
3693 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
3700 // $ANTLR end "parameterValue"
\r
3702 public static class rangePar_return extends ParserRuleReturnScope {
\r
3704 public Object getTree() { return tree; }
\r
3707 // $ANTLR start "rangePar"
\r
3708 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:366:1: rangePar : ( LBRACKET | LPAREN ) range ( RBRACKET | RPAREN ) ;
\r
3709 public final GraphParser.rangePar_return rangePar() throws RecognitionException {
\r
3710 GraphParser.rangePar_return retval = new GraphParser.rangePar_return();
\r
3711 retval.start = input.LT(1);
\r
3713 CommonTree root_0 = null;
\r
3716 Token set101=null;
\r
3717 GraphParser.range_return range100 = null;
\r
3720 CommonTree set99_tree=null;
\r
3721 CommonTree set101_tree=null;
\r
3724 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:366:10: ( ( LBRACKET | LPAREN ) range ( RBRACKET | RPAREN ) )
\r
3725 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:366:12: ( LBRACKET | LPAREN ) range ( RBRACKET | RPAREN )
\r
3727 root_0 = (CommonTree)adaptor.nil();
\r
3729 set99=(Token)input.LT(1);
\r
3730 if ( input.LA(1)==LPAREN||input.LA(1)==LBRACKET ) {
\r
3732 if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set99));
\r
3733 state.errorRecovery=false;state.failed=false;
\r
3736 if (state.backtracking>0) {state.failed=true; return retval;}
\r
3737 MismatchedSetException mse = new MismatchedSetException(null,input);
\r
3741 pushFollow(FOLLOW_range_in_rangePar2507);
\r
3745 if (state.failed) return retval;
\r
3746 if ( state.backtracking==0 ) adaptor.addChild(root_0, range100.getTree());
\r
3747 set101=(Token)input.LT(1);
\r
3748 if ( input.LA(1)==RPAREN||input.LA(1)==RBRACKET ) {
\r
3750 if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set101));
\r
3751 state.errorRecovery=false;state.failed=false;
\r
3754 if (state.backtracking>0) {state.failed=true; return retval;}
\r
3755 MismatchedSetException mse = new MismatchedSetException(null,input);
\r
3762 retval.stop = input.LT(-1);
\r
3764 if ( state.backtracking==0 ) {
\r
3766 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
3767 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
3770 catch (RecognitionException re) {
\r
3772 recover(input,re);
\r
3773 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
3780 // $ANTLR end "rangePar"
\r
3782 public static class range_return extends ParserRuleReturnScope {
\r
3784 public Object getTree() { return tree; }
\r
3787 // $ANTLR start "range"
\r
3788 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:368:1: range : ( number | RANGE | INT_RANGE );
\r
3789 public final GraphParser.range_return range() throws RecognitionException {
\r
3790 GraphParser.range_return retval = new GraphParser.range_return();
\r
3791 retval.start = input.LT(1);
\r
3793 CommonTree root_0 = null;
\r
3795 Token RANGE103=null;
\r
3796 Token INT_RANGE104=null;
\r
3797 GraphParser.number_return number102 = null;
\r
3800 CommonTree RANGE103_tree=null;
\r
3801 CommonTree INT_RANGE104_tree=null;
\r
3804 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:369:5: ( number | RANGE | INT_RANGE )
\r
3806 switch ( input.LA(1) ) {
\r
3824 if (state.backtracking>0) {state.failed=true; return retval;}
\r
3825 NoViableAltException nvae =
\r
3826 new NoViableAltException("", 34, 0, input);
\r
3833 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:369:7: number
\r
3835 root_0 = (CommonTree)adaptor.nil();
\r
3837 pushFollow(FOLLOW_number_in_range2536);
\r
3838 number102=number();
\r
3841 if (state.failed) return retval;
\r
3842 if ( state.backtracking==0 ) adaptor.addChild(root_0, number102.getTree());
\r
3847 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:370:7: RANGE
\r
3849 root_0 = (CommonTree)adaptor.nil();
\r
3851 RANGE103=(Token)match(input,RANGE,FOLLOW_RANGE_in_range2544); if (state.failed) return retval;
\r
3852 if ( state.backtracking==0 ) {
\r
3853 RANGE103_tree = (CommonTree)adaptor.create(RANGE103);
\r
3854 adaptor.addChild(root_0, RANGE103_tree);
\r
3860 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:371:7: INT_RANGE
\r
3862 root_0 = (CommonTree)adaptor.nil();
\r
3864 INT_RANGE104=(Token)match(input,INT_RANGE,FOLLOW_INT_RANGE_in_range2552); if (state.failed) return retval;
\r
3865 if ( state.backtracking==0 ) {
\r
3866 INT_RANGE104_tree = (CommonTree)adaptor.create(INT_RANGE104);
\r
3867 adaptor.addChild(root_0, INT_RANGE104_tree);
\r
3874 retval.stop = input.LT(-1);
\r
3876 if ( state.backtracking==0 ) {
\r
3878 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
3879 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
3882 catch (RecognitionException re) {
\r
3884 recover(input,re);
\r
3885 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
3892 // $ANTLR end "range"
\r
3894 public static class number_return extends ParserRuleReturnScope {
\r
3896 public Object getTree() { return tree; }
\r
3899 // $ANTLR start "number"
\r
3900 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:374:1: number : ( INT | FLOAT );
\r
3901 public final GraphParser.number_return number() throws RecognitionException {
\r
3902 GraphParser.number_return retval = new GraphParser.number_return();
\r
3903 retval.start = input.LT(1);
\r
3905 CommonTree root_0 = null;
\r
3907 Token set105=null;
\r
3909 CommonTree set105_tree=null;
\r
3912 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:375:5: ( INT | FLOAT )
\r
3913 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:
\r
3915 root_0 = (CommonTree)adaptor.nil();
\r
3917 set105=(Token)input.LT(1);
\r
3918 if ( input.LA(1)==INT||input.LA(1)==FLOAT ) {
\r
3920 if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set105));
\r
3921 state.errorRecovery=false;state.failed=false;
\r
3924 if (state.backtracking>0) {state.failed=true; return retval;}
\r
3925 MismatchedSetException mse = new MismatchedSetException(null,input);
\r
3932 retval.stop = input.LT(-1);
\r
3934 if ( state.backtracking==0 ) {
\r
3936 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
3937 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
3940 catch (RecognitionException re) {
\r
3942 recover(input,re);
\r
3943 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
3950 // $ANTLR end "number"
\r
3952 public static class string_return extends ParserRuleReturnScope {
\r
3954 public Object getTree() { return tree; }
\r
3957 // $ANTLR start "string"
\r
3958 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:379:1: string : STRING ;
\r
3959 public final GraphParser.string_return string() throws RecognitionException {
\r
3960 GraphParser.string_return retval = new GraphParser.string_return();
\r
3961 retval.start = input.LT(1);
\r
3963 CommonTree root_0 = null;
\r
3965 Token STRING106=null;
\r
3967 CommonTree STRING106_tree=null;
\r
3970 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:380:5: ( STRING )
\r
3971 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:380:7: STRING
\r
3973 root_0 = (CommonTree)adaptor.nil();
\r
3975 STRING106=(Token)match(input,STRING,FOLLOW_STRING_in_string2606); if (state.failed) return retval;
\r
3976 if ( state.backtracking==0 ) {
\r
3977 STRING106_tree = (CommonTree)adaptor.create(STRING106);
\r
3978 adaptor.addChild(root_0, STRING106_tree);
\r
3983 retval.stop = input.LT(-1);
\r
3985 if ( state.backtracking==0 ) {
\r
3987 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
3988 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
3991 catch (RecognitionException re) {
\r
3993 recover(input,re);
\r
3994 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
4001 // $ANTLR end "string"
\r
4003 public static class boolean__return extends ParserRuleReturnScope {
\r
4005 public Object getTree() { return tree; }
\r
4008 // $ANTLR start "boolean_"
\r
4009 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:383:1: boolean_ : ( 'true' -> TRUE | 'false' -> FALSE );
\r
4010 public final GraphParser.boolean__return boolean_() throws RecognitionException {
\r
4011 GraphParser.boolean__return retval = new GraphParser.boolean__return();
\r
4012 retval.start = input.LT(1);
\r
4014 CommonTree root_0 = null;
\r
4016 Token string_literal107=null;
\r
4017 Token string_literal108=null;
\r
4019 CommonTree string_literal107_tree=null;
\r
4020 CommonTree string_literal108_tree=null;
\r
4021 RewriteRuleTokenStream stream_79=new RewriteRuleTokenStream(adaptor,"token 79");
\r
4022 RewriteRuleTokenStream stream_80=new RewriteRuleTokenStream(adaptor,"token 80");
\r
4025 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:384:5: ( 'true' -> TRUE | 'false' -> FALSE )
\r
4027 int LA35_0 = input.LA(1);
\r
4029 if ( (LA35_0==79) ) {
\r
4032 else if ( (LA35_0==80) ) {
\r
4036 if (state.backtracking>0) {state.failed=true; return retval;}
\r
4037 NoViableAltException nvae =
\r
4038 new NoViableAltException("", 35, 0, input);
\r
4044 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:384:7: 'true'
\r
4046 string_literal107=(Token)match(input,79,FOLLOW_79_in_boolean_2627); if (state.failed) return retval;
\r
4047 if ( state.backtracking==0 ) stream_79.add(string_literal107);
\r
4054 // rule labels: retval
\r
4055 // token list labels:
\r
4056 // rule list labels:
\r
4057 // wildcard labels:
\r
4058 if ( state.backtracking==0 ) {
\r
4059 retval.tree = root_0;
\r
4060 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
4062 root_0 = (CommonTree)adaptor.nil();
\r
4063 // 384:14: -> TRUE
\r
4065 adaptor.addChild(root_0, (CommonTree)adaptor.create(TRUE, "TRUE"));
\r
4069 retval.tree = root_0;}
\r
4073 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:385:7: 'false'
\r
4075 string_literal108=(Token)match(input,80,FOLLOW_80_in_boolean_2639); if (state.failed) return retval;
\r
4076 if ( state.backtracking==0 ) stream_80.add(string_literal108);
\r
4083 // rule labels: retval
\r
4084 // token list labels:
\r
4085 // rule list labels:
\r
4086 // wildcard labels:
\r
4087 if ( state.backtracking==0 ) {
\r
4088 retval.tree = root_0;
\r
4089 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
4091 root_0 = (CommonTree)adaptor.nil();
\r
4092 // 385:15: -> FALSE
\r
4094 adaptor.addChild(root_0, (CommonTree)adaptor.create(FALSE, "FALSE"));
\r
4098 retval.tree = root_0;}
\r
4103 retval.stop = input.LT(-1);
\r
4105 if ( state.backtracking==0 ) {
\r
4107 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
4108 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
4111 catch (RecognitionException re) {
\r
4113 recover(input,re);
\r
4114 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
4121 // $ANTLR end "boolean_"
\r
4123 public static class valueDefinitions_return extends ParserRuleReturnScope {
\r
4125 public Object getTree() { return tree; }
\r
4128 // $ANTLR start "valueDefinitions"
\r
4129 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:392:1: valueDefinitions : ( valueDefinition )* -> ^( VALUE_DEFINITIONS ( valueDefinition )* ) ;
\r
4130 public final GraphParser.valueDefinitions_return valueDefinitions() throws RecognitionException {
\r
4131 GraphParser.valueDefinitions_return retval = new GraphParser.valueDefinitions_return();
\r
4132 retval.start = input.LT(1);
\r
4134 CommonTree root_0 = null;
\r
4136 GraphParser.valueDefinition_return valueDefinition109 = null;
\r
4139 RewriteRuleSubtreeStream stream_valueDefinition=new RewriteRuleSubtreeStream(adaptor,"rule valueDefinition");
\r
4141 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:392:18: ( ( valueDefinition )* -> ^( VALUE_DEFINITIONS ( valueDefinition )* ) )
\r
4142 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:392:20: ( valueDefinition )*
\r
4144 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:392:20: ( valueDefinition )*
\r
4148 int LA36_0 = input.LA(1);
\r
4150 if ( (LA36_0==ID) ) {
\r
4157 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:392:20: valueDefinition
\r
4159 pushFollow(FOLLOW_valueDefinition_in_valueDefinitions2660);
\r
4160 valueDefinition109=valueDefinition();
\r
4163 if (state.failed) return retval;
\r
4164 if ( state.backtracking==0 ) stream_valueDefinition.add(valueDefinition109.getTree());
\r
4177 // elements: valueDefinition
\r
4179 // rule labels: retval
\r
4180 // token list labels:
\r
4181 // rule list labels:
\r
4182 // wildcard labels:
\r
4183 if ( state.backtracking==0 ) {
\r
4184 retval.tree = root_0;
\r
4185 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
4187 root_0 = (CommonTree)adaptor.nil();
\r
4188 // 392:37: -> ^( VALUE_DEFINITIONS ( valueDefinition )* )
\r
4190 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:392:40: ^( VALUE_DEFINITIONS ( valueDefinition )* )
\r
4192 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
4193 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(VALUE_DEFINITIONS, "VALUE_DEFINITIONS"), root_1);
\r
4195 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:392:60: ( valueDefinition )*
\r
4196 while ( stream_valueDefinition.hasNext() ) {
\r
4197 adaptor.addChild(root_1, stream_valueDefinition.nextTree());
\r
4200 stream_valueDefinition.reset();
\r
4202 adaptor.addChild(root_0, root_1);
\r
4207 retval.tree = root_0;}
\r
4210 retval.stop = input.LT(-1);
\r
4212 if ( state.backtracking==0 ) {
\r
4214 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
4215 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
4218 catch (RecognitionException re) {
\r
4220 recover(input,re);
\r
4221 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
4228 // $ANTLR end "valueDefinitions"
\r
4230 public static class valueDefinition_return extends ParserRuleReturnScope {
\r
4232 public Object getTree() { return tree; }
\r
4235 // $ANTLR start "valueDefinition"
\r
4236 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:394:1: valueDefinition : ID ':' type '=' value -> ^( VALUE_DEFINITION ID type value ) ;
\r
4237 public final GraphParser.valueDefinition_return valueDefinition() throws RecognitionException {
\r
4238 GraphParser.valueDefinition_return retval = new GraphParser.valueDefinition_return();
\r
4239 retval.start = input.LT(1);
\r
4241 CommonTree root_0 = null;
\r
4244 Token char_literal111=null;
\r
4245 Token char_literal113=null;
\r
4246 GraphParser.type_return type112 = null;
\r
4248 GraphParser.value_return value114 = null;
\r
4251 CommonTree ID110_tree=null;
\r
4252 CommonTree char_literal111_tree=null;
\r
4253 CommonTree char_literal113_tree=null;
\r
4254 RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
\r
4255 RewriteRuleTokenStream stream_73=new RewriteRuleTokenStream(adaptor,"token 73");
\r
4256 RewriteRuleTokenStream stream_74=new RewriteRuleTokenStream(adaptor,"token 74");
\r
4257 RewriteRuleSubtreeStream stream_value=new RewriteRuleSubtreeStream(adaptor,"rule value");
\r
4258 RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
\r
4260 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:395:5: ( ID ':' type '=' value -> ^( VALUE_DEFINITION ID type value ) )
\r
4261 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:395:7: ID ':' type '=' value
\r
4263 ID110=(Token)match(input,ID,FOLLOW_ID_in_valueDefinition2683); if (state.failed) return retval;
\r
4264 if ( state.backtracking==0 ) stream_ID.add(ID110);
\r
4266 char_literal111=(Token)match(input,73,FOLLOW_73_in_valueDefinition2685); if (state.failed) return retval;
\r
4267 if ( state.backtracking==0 ) stream_73.add(char_literal111);
\r
4269 pushFollow(FOLLOW_type_in_valueDefinition2687);
\r
4273 if (state.failed) return retval;
\r
4274 if ( state.backtracking==0 ) stream_type.add(type112.getTree());
\r
4275 char_literal113=(Token)match(input,74,FOLLOW_74_in_valueDefinition2689); if (state.failed) return retval;
\r
4276 if ( state.backtracking==0 ) stream_74.add(char_literal113);
\r
4278 pushFollow(FOLLOW_value_in_valueDefinition2691);
\r
4282 if (state.failed) return retval;
\r
4283 if ( state.backtracking==0 ) stream_value.add(value114.getTree());
\r
4287 // elements: value, type, ID
\r
4289 // rule labels: retval
\r
4290 // token list labels:
\r
4291 // rule list labels:
\r
4292 // wildcard labels:
\r
4293 if ( state.backtracking==0 ) {
\r
4294 retval.tree = root_0;
\r
4295 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
4297 root_0 = (CommonTree)adaptor.nil();
\r
4298 // 396:5: -> ^( VALUE_DEFINITION ID type value )
\r
4300 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:396:8: ^( VALUE_DEFINITION ID type value )
\r
4302 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
4303 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(VALUE_DEFINITION, "VALUE_DEFINITION"), root_1);
\r
4305 adaptor.addChild(root_1, stream_ID.nextNode());
\r
4306 adaptor.addChild(root_1, stream_type.nextTree());
\r
4307 adaptor.addChild(root_1, stream_value.nextTree());
\r
4309 adaptor.addChild(root_0, root_1);
\r
4314 retval.tree = root_0;}
\r
4317 retval.stop = input.LT(-1);
\r
4319 if ( state.backtracking==0 ) {
\r
4321 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
4322 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
4325 catch (RecognitionException re) {
\r
4327 recover(input,re);
\r
4328 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
4335 // $ANTLR end "valueDefinition"
\r
4337 public static class value_return extends ParserRuleReturnScope {
\r
4339 public Object getTree() { return tree; }
\r
4342 // $ANTLR start "value"
\r
4343 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:399:1: value : ( basicValue -> basicValue ) ( ':' type -> ^( VARIANT type $value) )* ;
\r
4344 public final GraphParser.value_return value() throws RecognitionException {
\r
4345 GraphParser.value_return retval = new GraphParser.value_return();
\r
4346 retval.start = input.LT(1);
\r
4348 CommonTree root_0 = null;
\r
4350 Token char_literal116=null;
\r
4351 GraphParser.basicValue_return basicValue115 = null;
\r
4353 GraphParser.type_return type117 = null;
\r
4356 CommonTree char_literal116_tree=null;
\r
4357 RewriteRuleTokenStream stream_73=new RewriteRuleTokenStream(adaptor,"token 73");
\r
4358 RewriteRuleSubtreeStream stream_basicValue=new RewriteRuleSubtreeStream(adaptor,"rule basicValue");
\r
4359 RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
\r
4361 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:400:5: ( ( basicValue -> basicValue ) ( ':' type -> ^( VARIANT type $value) )* )
\r
4362 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:400:7: ( basicValue -> basicValue ) ( ':' type -> ^( VARIANT type $value) )*
\r
4364 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:400:7: ( basicValue -> basicValue )
\r
4365 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:400:8: basicValue
\r
4367 pushFollow(FOLLOW_basicValue_in_value2727);
\r
4368 basicValue115=basicValue();
\r
4371 if (state.failed) return retval;
\r
4372 if ( state.backtracking==0 ) stream_basicValue.add(basicValue115.getTree());
\r
4376 // elements: basicValue
\r
4378 // rule labels: retval
\r
4379 // token list labels:
\r
4380 // rule list labels:
\r
4381 // wildcard labels:
\r
4382 if ( state.backtracking==0 ) {
\r
4383 retval.tree = root_0;
\r
4384 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
4386 root_0 = (CommonTree)adaptor.nil();
\r
4387 // 400:19: -> basicValue
\r
4389 adaptor.addChild(root_0, stream_basicValue.nextTree());
\r
4393 retval.tree = root_0;}
\r
4396 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:401:7: ( ':' type -> ^( VARIANT type $value) )*
\r
4400 int LA37_0 = input.LA(1);
\r
4402 if ( (LA37_0==73) ) {
\r
4409 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:401:8: ':' type
\r
4411 char_literal116=(Token)match(input,73,FOLLOW_73_in_value2741); if (state.failed) return retval;
\r
4412 if ( state.backtracking==0 ) stream_73.add(char_literal116);
\r
4414 pushFollow(FOLLOW_type_in_value2743);
\r
4418 if (state.failed) return retval;
\r
4419 if ( state.backtracking==0 ) stream_type.add(type117.getTree());
\r
4423 // elements: value, type
\r
4425 // rule labels: retval
\r
4426 // token list labels:
\r
4427 // rule list labels:
\r
4428 // wildcard labels:
\r
4429 if ( state.backtracking==0 ) {
\r
4430 retval.tree = root_0;
\r
4431 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
4433 root_0 = (CommonTree)adaptor.nil();
\r
4434 // 401:17: -> ^( VARIANT type $value)
\r
4436 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:401:20: ^( VARIANT type $value)
\r
4438 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
4439 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(VARIANT, "VARIANT"), root_1);
\r
4441 adaptor.addChild(root_1, stream_type.nextTree());
\r
4442 adaptor.addChild(root_1, stream_retval.nextTree());
\r
4444 adaptor.addChild(root_0, root_1);
\r
4449 retval.tree = root_0;}
\r
4461 retval.stop = input.LT(-1);
\r
4463 if ( state.backtracking==0 ) {
\r
4465 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
4466 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
4469 catch (RecognitionException re) {
\r
4471 recover(input,re);
\r
4472 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
4479 // $ANTLR end "value"
\r
4481 public static class basicValue_return extends ParserRuleReturnScope {
\r
4483 public Object getTree() { return tree; }
\r
4486 // $ANTLR start "basicValue"
\r
4487 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:404:1: basicValue : ( simpleValue | map | {...}? ID -> NO_VALUE | taggedValue );
\r
4488 public final GraphParser.basicValue_return basicValue() throws RecognitionException {
\r
4489 GraphParser.basicValue_return retval = new GraphParser.basicValue_return();
\r
4490 retval.start = input.LT(1);
\r
4492 CommonTree root_0 = null;
\r
4495 GraphParser.simpleValue_return simpleValue118 = null;
\r
4497 GraphParser.map_return map119 = null;
\r
4499 GraphParser.taggedValue_return taggedValue121 = null;
\r
4502 CommonTree ID120_tree=null;
\r
4503 RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
\r
4506 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:405:5: ( simpleValue | map | {...}? ID -> NO_VALUE | taggedValue )
\r
4508 int LA38_0 = input.LA(1);
\r
4510 if ( (LA38_0==LPAREN||LA38_0==LBRACKET||LA38_0==LCURLY||LA38_0==INT||LA38_0==FLOAT||LA38_0==STRING||(LA38_0>=79 && LA38_0<=80)) ) {
\r
4513 else if ( (LA38_0==ID) ) {
\r
4514 int LA38_2 = input.LA(2);
\r
4516 if ( (LA38_2==LCURLY) && ((input.LT(1).getText().equals("map")))) {
\r
4519 else if ( ((input.LT(1).getText().equals("null"))) ) {
\r
4522 else if ( (true) ) {
\r
4526 if (state.backtracking>0) {state.failed=true; return retval;}
\r
4527 NoViableAltException nvae =
\r
4528 new NoViableAltException("", 38, 2, input);
\r
4534 if (state.backtracking>0) {state.failed=true; return retval;}
\r
4535 NoViableAltException nvae =
\r
4536 new NoViableAltException("", 38, 0, input);
\r
4542 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:405:7: simpleValue
\r
4544 root_0 = (CommonTree)adaptor.nil();
\r
4546 pushFollow(FOLLOW_simpleValue_in_basicValue2775);
\r
4547 simpleValue118=simpleValue();
\r
4550 if (state.failed) return retval;
\r
4551 if ( state.backtracking==0 ) adaptor.addChild(root_0, simpleValue118.getTree());
\r
4556 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:406:7: map
\r
4558 root_0 = (CommonTree)adaptor.nil();
\r
4560 pushFollow(FOLLOW_map_in_basicValue2783);
\r
4564 if (state.failed) return retval;
\r
4565 if ( state.backtracking==0 ) adaptor.addChild(root_0, map119.getTree());
\r
4570 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:407:7: {...}? ID
\r
4572 if ( !((input.LT(1).getText().equals("null"))) ) {
\r
4573 if (state.backtracking>0) {state.failed=true; return retval;}
\r
4574 throw new FailedPredicateException(input, "basicValue", "input.LT(1).getText().equals(\"null\")");
\r
4576 ID120=(Token)match(input,ID,FOLLOW_ID_in_basicValue2793); if (state.failed) return retval;
\r
4577 if ( state.backtracking==0 ) stream_ID.add(ID120);
\r
4584 // rule labels: retval
\r
4585 // token list labels:
\r
4586 // rule list labels:
\r
4587 // wildcard labels:
\r
4588 if ( state.backtracking==0 ) {
\r
4589 retval.tree = root_0;
\r
4590 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
4592 root_0 = (CommonTree)adaptor.nil();
\r
4593 // 407:50: -> NO_VALUE
\r
4595 adaptor.addChild(root_0, (CommonTree)adaptor.create(NO_VALUE, "NO_VALUE"));
\r
4599 retval.tree = root_0;}
\r
4603 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:408:7: taggedValue
\r
4605 root_0 = (CommonTree)adaptor.nil();
\r
4607 pushFollow(FOLLOW_taggedValue_in_basicValue2805);
\r
4608 taggedValue121=taggedValue();
\r
4611 if (state.failed) return retval;
\r
4612 if ( state.backtracking==0 ) adaptor.addChild(root_0, taggedValue121.getTree());
\r
4618 retval.stop = input.LT(-1);
\r
4620 if ( state.backtracking==0 ) {
\r
4622 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
4623 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
4626 catch (RecognitionException re) {
\r
4628 recover(input,re);
\r
4629 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
4636 // $ANTLR end "basicValue"
\r
4638 public static class simpleValue_return extends ParserRuleReturnScope {
\r
4640 public Object getTree() { return tree; }
\r
4643 // $ANTLR start "simpleValue"
\r
4644 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:411:1: simpleValue : ( string | number | boolean_ | array | tuple | record );
\r
4645 public final GraphParser.simpleValue_return simpleValue() throws RecognitionException {
\r
4646 GraphParser.simpleValue_return retval = new GraphParser.simpleValue_return();
\r
4647 retval.start = input.LT(1);
\r
4649 CommonTree root_0 = null;
\r
4651 GraphParser.string_return string122 = null;
\r
4653 GraphParser.number_return number123 = null;
\r
4655 GraphParser.boolean__return boolean_124 = null;
\r
4657 GraphParser.array_return array125 = null;
\r
4659 GraphParser.tuple_return tuple126 = null;
\r
4661 GraphParser.record_return record127 = null;
\r
4666 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:412:5: ( string | number | boolean_ | array | tuple | record )
\r
4668 switch ( input.LA(1) ) {
\r
4702 if (state.backtracking>0) {state.failed=true; return retval;}
\r
4703 NoViableAltException nvae =
\r
4704 new NoViableAltException("", 39, 0, input);
\r
4711 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:412:7: string
\r
4713 root_0 = (CommonTree)adaptor.nil();
\r
4715 pushFollow(FOLLOW_string_in_simpleValue2830);
\r
4716 string122=string();
\r
4719 if (state.failed) return retval;
\r
4720 if ( state.backtracking==0 ) adaptor.addChild(root_0, string122.getTree());
\r
4725 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:413:7: number
\r
4727 root_0 = (CommonTree)adaptor.nil();
\r
4729 pushFollow(FOLLOW_number_in_simpleValue2838);
\r
4730 number123=number();
\r
4733 if (state.failed) return retval;
\r
4734 if ( state.backtracking==0 ) adaptor.addChild(root_0, number123.getTree());
\r
4739 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:414:7: boolean_
\r
4741 root_0 = (CommonTree)adaptor.nil();
\r
4743 pushFollow(FOLLOW_boolean__in_simpleValue2846);
\r
4744 boolean_124=boolean_();
\r
4747 if (state.failed) return retval;
\r
4748 if ( state.backtracking==0 ) adaptor.addChild(root_0, boolean_124.getTree());
\r
4753 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:415:7: array
\r
4755 root_0 = (CommonTree)adaptor.nil();
\r
4757 pushFollow(FOLLOW_array_in_simpleValue2854);
\r
4761 if (state.failed) return retval;
\r
4762 if ( state.backtracking==0 ) adaptor.addChild(root_0, array125.getTree());
\r
4767 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:416:7: tuple
\r
4769 root_0 = (CommonTree)adaptor.nil();
\r
4771 pushFollow(FOLLOW_tuple_in_simpleValue2862);
\r
4775 if (state.failed) return retval;
\r
4776 if ( state.backtracking==0 ) adaptor.addChild(root_0, tuple126.getTree());
\r
4781 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:417:7: record
\r
4783 root_0 = (CommonTree)adaptor.nil();
\r
4785 pushFollow(FOLLOW_record_in_simpleValue2870);
\r
4786 record127=record();
\r
4789 if (state.failed) return retval;
\r
4790 if ( state.backtracking==0 ) adaptor.addChild(root_0, record127.getTree());
\r
4796 retval.stop = input.LT(-1);
\r
4798 if ( state.backtracking==0 ) {
\r
4800 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
4801 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
4804 catch (RecognitionException re) {
\r
4806 recover(input,re);
\r
4807 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
4814 // $ANTLR end "simpleValue"
\r
4816 public static class array_return extends ParserRuleReturnScope {
\r
4818 public Object getTree() { return tree; }
\r
4821 // $ANTLR start "array"
\r
4822 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:420:1: array : LBRACKET ( value ( ',' value )* )? RBRACKET -> ^( ARRAY ( value )* ) ;
\r
4823 public final GraphParser.array_return array() throws RecognitionException {
\r
4824 GraphParser.array_return retval = new GraphParser.array_return();
\r
4825 retval.start = input.LT(1);
\r
4827 CommonTree root_0 = null;
\r
4829 Token LBRACKET128=null;
\r
4830 Token char_literal130=null;
\r
4831 Token RBRACKET132=null;
\r
4832 GraphParser.value_return value129 = null;
\r
4834 GraphParser.value_return value131 = null;
\r
4837 CommonTree LBRACKET128_tree=null;
\r
4838 CommonTree char_literal130_tree=null;
\r
4839 CommonTree RBRACKET132_tree=null;
\r
4840 RewriteRuleTokenStream stream_LBRACKET=new RewriteRuleTokenStream(adaptor,"token LBRACKET");
\r
4841 RewriteRuleTokenStream stream_78=new RewriteRuleTokenStream(adaptor,"token 78");
\r
4842 RewriteRuleTokenStream stream_RBRACKET=new RewriteRuleTokenStream(adaptor,"token RBRACKET");
\r
4843 RewriteRuleSubtreeStream stream_value=new RewriteRuleSubtreeStream(adaptor,"rule value");
\r
4845 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:421:5: ( LBRACKET ( value ( ',' value )* )? RBRACKET -> ^( ARRAY ( value )* ) )
\r
4846 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:421:7: LBRACKET ( value ( ',' value )* )? RBRACKET
\r
4848 LBRACKET128=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_array2891); if (state.failed) return retval;
\r
4849 if ( state.backtracking==0 ) stream_LBRACKET.add(LBRACKET128);
\r
4851 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:421:16: ( value ( ',' value )* )?
\r
4853 int LA41_0 = input.LA(1);
\r
4855 if ( (LA41_0==ID||LA41_0==LPAREN||LA41_0==LBRACKET||LA41_0==LCURLY||LA41_0==INT||LA41_0==FLOAT||LA41_0==STRING||(LA41_0>=79 && LA41_0<=80)) ) {
\r
4860 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:421:17: value ( ',' value )*
\r
4862 pushFollow(FOLLOW_value_in_array2894);
\r
4866 if (state.failed) return retval;
\r
4867 if ( state.backtracking==0 ) stream_value.add(value129.getTree());
\r
4868 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:421:23: ( ',' value )*
\r
4872 int LA40_0 = input.LA(1);
\r
4874 if ( (LA40_0==78) ) {
\r
4881 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:421:24: ',' value
\r
4883 char_literal130=(Token)match(input,78,FOLLOW_78_in_array2897); if (state.failed) return retval;
\r
4884 if ( state.backtracking==0 ) stream_78.add(char_literal130);
\r
4886 pushFollow(FOLLOW_value_in_array2899);
\r
4890 if (state.failed) return retval;
\r
4891 if ( state.backtracking==0 ) stream_value.add(value131.getTree());
\r
4907 RBRACKET132=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_array2905); if (state.failed) return retval;
\r
4908 if ( state.backtracking==0 ) stream_RBRACKET.add(RBRACKET132);
\r
4913 // elements: value
\r
4915 // rule labels: retval
\r
4916 // token list labels:
\r
4917 // rule list labels:
\r
4918 // wildcard labels:
\r
4919 if ( state.backtracking==0 ) {
\r
4920 retval.tree = root_0;
\r
4921 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
4923 root_0 = (CommonTree)adaptor.nil();
\r
4924 // 422:5: -> ^( ARRAY ( value )* )
\r
4926 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:422:8: ^( ARRAY ( value )* )
\r
4928 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
4929 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ARRAY, "ARRAY"), root_1);
\r
4931 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:422:16: ( value )*
\r
4932 while ( stream_value.hasNext() ) {
\r
4933 adaptor.addChild(root_1, stream_value.nextTree());
\r
4936 stream_value.reset();
\r
4938 adaptor.addChild(root_0, root_1);
\r
4943 retval.tree = root_0;}
\r
4946 retval.stop = input.LT(-1);
\r
4948 if ( state.backtracking==0 ) {
\r
4950 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
4951 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
4954 catch (RecognitionException re) {
\r
4956 recover(input,re);
\r
4957 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
4964 // $ANTLR end "array"
\r
4966 public static class tuple_return extends ParserRuleReturnScope {
\r
4968 public Object getTree() { return tree; }
\r
4971 // $ANTLR start "tuple"
\r
4972 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:425:1: tuple : LPAREN ( value ( ',' value )* )? RPAREN -> ^( TUPLE ( value )* ) ;
\r
4973 public final GraphParser.tuple_return tuple() throws RecognitionException {
\r
4974 GraphParser.tuple_return retval = new GraphParser.tuple_return();
\r
4975 retval.start = input.LT(1);
\r
4977 CommonTree root_0 = null;
\r
4979 Token LPAREN133=null;
\r
4980 Token char_literal135=null;
\r
4981 Token RPAREN137=null;
\r
4982 GraphParser.value_return value134 = null;
\r
4984 GraphParser.value_return value136 = null;
\r
4987 CommonTree LPAREN133_tree=null;
\r
4988 CommonTree char_literal135_tree=null;
\r
4989 CommonTree RPAREN137_tree=null;
\r
4990 RewriteRuleTokenStream stream_78=new RewriteRuleTokenStream(adaptor,"token 78");
\r
4991 RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
\r
4992 RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
\r
4993 RewriteRuleSubtreeStream stream_value=new RewriteRuleSubtreeStream(adaptor,"rule value");
\r
4995 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:426:5: ( LPAREN ( value ( ',' value )* )? RPAREN -> ^( TUPLE ( value )* ) )
\r
4996 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:426:7: LPAREN ( value ( ',' value )* )? RPAREN
\r
4998 LPAREN133=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_tuple2937); if (state.failed) return retval;
\r
4999 if ( state.backtracking==0 ) stream_LPAREN.add(LPAREN133);
\r
5001 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:426:14: ( value ( ',' value )* )?
\r
5003 int LA43_0 = input.LA(1);
\r
5005 if ( (LA43_0==ID||LA43_0==LPAREN||LA43_0==LBRACKET||LA43_0==LCURLY||LA43_0==INT||LA43_0==FLOAT||LA43_0==STRING||(LA43_0>=79 && LA43_0<=80)) ) {
\r
5010 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:426:15: value ( ',' value )*
\r
5012 pushFollow(FOLLOW_value_in_tuple2940);
\r
5016 if (state.failed) return retval;
\r
5017 if ( state.backtracking==0 ) stream_value.add(value134.getTree());
\r
5018 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:426:21: ( ',' value )*
\r
5022 int LA42_0 = input.LA(1);
\r
5024 if ( (LA42_0==78) ) {
\r
5031 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:426:22: ',' value
\r
5033 char_literal135=(Token)match(input,78,FOLLOW_78_in_tuple2943); if (state.failed) return retval;
\r
5034 if ( state.backtracking==0 ) stream_78.add(char_literal135);
\r
5036 pushFollow(FOLLOW_value_in_tuple2945);
\r
5040 if (state.failed) return retval;
\r
5041 if ( state.backtracking==0 ) stream_value.add(value136.getTree());
\r
5057 RPAREN137=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_tuple2951); if (state.failed) return retval;
\r
5058 if ( state.backtracking==0 ) stream_RPAREN.add(RPAREN137);
\r
5063 // elements: value
\r
5065 // rule labels: retval
\r
5066 // token list labels:
\r
5067 // rule list labels:
\r
5068 // wildcard labels:
\r
5069 if ( state.backtracking==0 ) {
\r
5070 retval.tree = root_0;
\r
5071 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
5073 root_0 = (CommonTree)adaptor.nil();
\r
5074 // 427:5: -> ^( TUPLE ( value )* )
\r
5076 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:427:8: ^( TUPLE ( value )* )
\r
5078 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
5079 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TUPLE, "TUPLE"), root_1);
\r
5081 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:427:16: ( value )*
\r
5082 while ( stream_value.hasNext() ) {
\r
5083 adaptor.addChild(root_1, stream_value.nextTree());
\r
5086 stream_value.reset();
\r
5088 adaptor.addChild(root_0, root_1);
\r
5093 retval.tree = root_0;}
\r
5096 retval.stop = input.LT(-1);
\r
5098 if ( state.backtracking==0 ) {
\r
5100 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
5101 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
5104 catch (RecognitionException re) {
\r
5106 recover(input,re);
\r
5107 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
5114 // $ANTLR end "tuple"
\r
5116 public static class taggedValue_return extends ParserRuleReturnScope {
\r
5118 public Object getTree() { return tree; }
\r
5121 // $ANTLR start "taggedValue"
\r
5122 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:430:1: taggedValue : ID ( simpleValue )? -> ^( TAGGED_VALUE ID ( simpleValue )? ) ;
\r
5123 public final GraphParser.taggedValue_return taggedValue() throws RecognitionException {
\r
5124 GraphParser.taggedValue_return retval = new GraphParser.taggedValue_return();
\r
5125 retval.start = input.LT(1);
\r
5127 CommonTree root_0 = null;
\r
5130 GraphParser.simpleValue_return simpleValue139 = null;
\r
5133 CommonTree ID138_tree=null;
\r
5134 RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
\r
5135 RewriteRuleSubtreeStream stream_simpleValue=new RewriteRuleSubtreeStream(adaptor,"rule simpleValue");
\r
5137 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:431:5: ( ID ( simpleValue )? -> ^( TAGGED_VALUE ID ( simpleValue )? ) )
\r
5138 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:431:7: ID ( simpleValue )?
\r
5140 ID138=(Token)match(input,ID,FOLLOW_ID_in_taggedValue2983); if (state.failed) return retval;
\r
5141 if ( state.backtracking==0 ) stream_ID.add(ID138);
\r
5143 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:431:10: ( simpleValue )?
\r
5145 int LA44_0 = input.LA(1);
\r
5147 if ( (LA44_0==LPAREN||LA44_0==LBRACKET||LA44_0==LCURLY||LA44_0==INT||LA44_0==FLOAT||LA44_0==STRING||(LA44_0>=79 && LA44_0<=80)) ) {
\r
5152 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:431:10: simpleValue
\r
5154 pushFollow(FOLLOW_simpleValue_in_taggedValue2985);
\r
5155 simpleValue139=simpleValue();
\r
5158 if (state.failed) return retval;
\r
5159 if ( state.backtracking==0 ) stream_simpleValue.add(simpleValue139.getTree());
\r
5169 // elements: simpleValue, ID
\r
5171 // rule labels: retval
\r
5172 // token list labels:
\r
5173 // rule list labels:
\r
5174 // wildcard labels:
\r
5175 if ( state.backtracking==0 ) {
\r
5176 retval.tree = root_0;
\r
5177 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
5179 root_0 = (CommonTree)adaptor.nil();
\r
5180 // 432:5: -> ^( TAGGED_VALUE ID ( simpleValue )? )
\r
5182 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:432:8: ^( TAGGED_VALUE ID ( simpleValue )? )
\r
5184 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
5185 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TAGGED_VALUE, "TAGGED_VALUE"), root_1);
\r
5187 adaptor.addChild(root_1, stream_ID.nextNode());
\r
5188 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:432:26: ( simpleValue )?
\r
5189 if ( stream_simpleValue.hasNext() ) {
\r
5190 adaptor.addChild(root_1, stream_simpleValue.nextTree());
\r
5193 stream_simpleValue.reset();
\r
5195 adaptor.addChild(root_0, root_1);
\r
5200 retval.tree = root_0;}
\r
5203 retval.stop = input.LT(-1);
\r
5205 if ( state.backtracking==0 ) {
\r
5207 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
5208 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
5211 catch (RecognitionException re) {
\r
5213 recover(input,re);
\r
5214 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
5221 // $ANTLR end "taggedValue"
\r
5223 public static class record_return extends ParserRuleReturnScope {
\r
5225 public Object getTree() { return tree; }
\r
5228 // $ANTLR start "record"
\r
5229 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:435:1: record : LCURLY ( recordAssignment ( ',' recordAssignment )* )? RCURLY -> ^( RECORD ( recordAssignment )* ) ;
\r
5230 public final GraphParser.record_return record() throws RecognitionException {
\r
5231 GraphParser.record_return retval = new GraphParser.record_return();
\r
5232 retval.start = input.LT(1);
\r
5234 CommonTree root_0 = null;
\r
5236 Token LCURLY140=null;
\r
5237 Token char_literal142=null;
\r
5238 Token RCURLY144=null;
\r
5239 GraphParser.recordAssignment_return recordAssignment141 = null;
\r
5241 GraphParser.recordAssignment_return recordAssignment143 = null;
\r
5244 CommonTree LCURLY140_tree=null;
\r
5245 CommonTree char_literal142_tree=null;
\r
5246 CommonTree RCURLY144_tree=null;
\r
5247 RewriteRuleTokenStream stream_78=new RewriteRuleTokenStream(adaptor,"token 78");
\r
5248 RewriteRuleTokenStream stream_LCURLY=new RewriteRuleTokenStream(adaptor,"token LCURLY");
\r
5249 RewriteRuleTokenStream stream_RCURLY=new RewriteRuleTokenStream(adaptor,"token RCURLY");
\r
5250 RewriteRuleSubtreeStream stream_recordAssignment=new RewriteRuleSubtreeStream(adaptor,"rule recordAssignment");
\r
5252 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:436:5: ( LCURLY ( recordAssignment ( ',' recordAssignment )* )? RCURLY -> ^( RECORD ( recordAssignment )* ) )
\r
5253 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:436:7: LCURLY ( recordAssignment ( ',' recordAssignment )* )? RCURLY
\r
5255 LCURLY140=(Token)match(input,LCURLY,FOLLOW_LCURLY_in_record3020); if (state.failed) return retval;
\r
5256 if ( state.backtracking==0 ) stream_LCURLY.add(LCURLY140);
\r
5258 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:436:14: ( recordAssignment ( ',' recordAssignment )* )?
\r
5260 int LA46_0 = input.LA(1);
\r
5262 if ( (LA46_0==ID) ) {
\r
5267 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:436:15: recordAssignment ( ',' recordAssignment )*
\r
5269 pushFollow(FOLLOW_recordAssignment_in_record3023);
\r
5270 recordAssignment141=recordAssignment();
\r
5273 if (state.failed) return retval;
\r
5274 if ( state.backtracking==0 ) stream_recordAssignment.add(recordAssignment141.getTree());
\r
5275 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:436:32: ( ',' recordAssignment )*
\r
5279 int LA45_0 = input.LA(1);
\r
5281 if ( (LA45_0==78) ) {
\r
5288 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:436:33: ',' recordAssignment
\r
5290 char_literal142=(Token)match(input,78,FOLLOW_78_in_record3026); if (state.failed) return retval;
\r
5291 if ( state.backtracking==0 ) stream_78.add(char_literal142);
\r
5293 pushFollow(FOLLOW_recordAssignment_in_record3028);
\r
5294 recordAssignment143=recordAssignment();
\r
5297 if (state.failed) return retval;
\r
5298 if ( state.backtracking==0 ) stream_recordAssignment.add(recordAssignment143.getTree());
\r
5314 RCURLY144=(Token)match(input,RCURLY,FOLLOW_RCURLY_in_record3034); if (state.failed) return retval;
\r
5315 if ( state.backtracking==0 ) stream_RCURLY.add(RCURLY144);
\r
5320 // elements: recordAssignment
\r
5322 // rule labels: retval
\r
5323 // token list labels:
\r
5324 // rule list labels:
\r
5325 // wildcard labels:
\r
5326 if ( state.backtracking==0 ) {
\r
5327 retval.tree = root_0;
\r
5328 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
5330 root_0 = (CommonTree)adaptor.nil();
\r
5331 // 437:5: -> ^( RECORD ( recordAssignment )* )
\r
5333 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:437:8: ^( RECORD ( recordAssignment )* )
\r
5335 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
5336 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(RECORD, "RECORD"), root_1);
\r
5338 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:437:17: ( recordAssignment )*
\r
5339 while ( stream_recordAssignment.hasNext() ) {
\r
5340 adaptor.addChild(root_1, stream_recordAssignment.nextTree());
\r
5343 stream_recordAssignment.reset();
\r
5345 adaptor.addChild(root_0, root_1);
\r
5350 retval.tree = root_0;}
\r
5353 retval.stop = input.LT(-1);
\r
5355 if ( state.backtracking==0 ) {
\r
5357 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
5358 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
5361 catch (RecognitionException re) {
\r
5363 recover(input,re);
\r
5364 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
5371 // $ANTLR end "record"
\r
5373 public static class recordAssignment_return extends ParserRuleReturnScope {
\r
5375 public Object getTree() { return tree; }
\r
5378 // $ANTLR start "recordAssignment"
\r
5379 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:440:1: recordAssignment : ID '=' value -> ^( ASSIGNMENT ID value ) ;
\r
5380 public final GraphParser.recordAssignment_return recordAssignment() throws RecognitionException {
\r
5381 GraphParser.recordAssignment_return retval = new GraphParser.recordAssignment_return();
\r
5382 retval.start = input.LT(1);
\r
5384 CommonTree root_0 = null;
\r
5387 Token char_literal146=null;
\r
5388 GraphParser.value_return value147 = null;
\r
5391 CommonTree ID145_tree=null;
\r
5392 CommonTree char_literal146_tree=null;
\r
5393 RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
\r
5394 RewriteRuleTokenStream stream_74=new RewriteRuleTokenStream(adaptor,"token 74");
\r
5395 RewriteRuleSubtreeStream stream_value=new RewriteRuleSubtreeStream(adaptor,"rule value");
\r
5397 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:441:5: ( ID '=' value -> ^( ASSIGNMENT ID value ) )
\r
5398 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:441:7: ID '=' value
\r
5400 ID145=(Token)match(input,ID,FOLLOW_ID_in_recordAssignment3066); if (state.failed) return retval;
\r
5401 if ( state.backtracking==0 ) stream_ID.add(ID145);
\r
5403 char_literal146=(Token)match(input,74,FOLLOW_74_in_recordAssignment3068); if (state.failed) return retval;
\r
5404 if ( state.backtracking==0 ) stream_74.add(char_literal146);
\r
5406 pushFollow(FOLLOW_value_in_recordAssignment3070);
\r
5410 if (state.failed) return retval;
\r
5411 if ( state.backtracking==0 ) stream_value.add(value147.getTree());
\r
5415 // elements: ID, value
\r
5417 // rule labels: retval
\r
5418 // token list labels:
\r
5419 // rule list labels:
\r
5420 // wildcard labels:
\r
5421 if ( state.backtracking==0 ) {
\r
5422 retval.tree = root_0;
\r
5423 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
5425 root_0 = (CommonTree)adaptor.nil();
\r
5426 // 442:5: -> ^( ASSIGNMENT ID value )
\r
5428 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:442:8: ^( ASSIGNMENT ID value )
\r
5430 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
5431 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ASSIGNMENT, "ASSIGNMENT"), root_1);
\r
5433 adaptor.addChild(root_1, stream_ID.nextNode());
\r
5434 adaptor.addChild(root_1, stream_value.nextTree());
\r
5436 adaptor.addChild(root_0, root_1);
\r
5441 retval.tree = root_0;}
\r
5444 retval.stop = input.LT(-1);
\r
5446 if ( state.backtracking==0 ) {
\r
5448 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
5449 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
5452 catch (RecognitionException re) {
\r
5454 recover(input,re);
\r
5455 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
5462 // $ANTLR end "recordAssignment"
\r
5464 public static class map_return extends ParserRuleReturnScope {
\r
5466 public Object getTree() { return tree; }
\r
5469 // $ANTLR start "map"
\r
5470 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:445:1: map : {...}? => ID LCURLY ( mapAssignment ( ',' mapAssignment )* )? RCURLY -> ^( MAP ( mapAssignment )* ) ;
\r
5471 public final GraphParser.map_return map() throws RecognitionException {
\r
5472 GraphParser.map_return retval = new GraphParser.map_return();
\r
5473 retval.start = input.LT(1);
\r
5475 CommonTree root_0 = null;
\r
5478 Token LCURLY149=null;
\r
5479 Token char_literal151=null;
\r
5480 Token RCURLY153=null;
\r
5481 GraphParser.mapAssignment_return mapAssignment150 = null;
\r
5483 GraphParser.mapAssignment_return mapAssignment152 = null;
\r
5486 CommonTree ID148_tree=null;
\r
5487 CommonTree LCURLY149_tree=null;
\r
5488 CommonTree char_literal151_tree=null;
\r
5489 CommonTree RCURLY153_tree=null;
\r
5490 RewriteRuleTokenStream stream_78=new RewriteRuleTokenStream(adaptor,"token 78");
\r
5491 RewriteRuleTokenStream stream_LCURLY=new RewriteRuleTokenStream(adaptor,"token LCURLY");
\r
5492 RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
\r
5493 RewriteRuleTokenStream stream_RCURLY=new RewriteRuleTokenStream(adaptor,"token RCURLY");
\r
5494 RewriteRuleSubtreeStream stream_mapAssignment=new RewriteRuleSubtreeStream(adaptor,"rule mapAssignment");
\r
5496 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:445:5: ({...}? => ID LCURLY ( mapAssignment ( ',' mapAssignment )* )? RCURLY -> ^( MAP ( mapAssignment )* ) )
\r
5497 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:445:7: {...}? => ID LCURLY ( mapAssignment ( ',' mapAssignment )* )? RCURLY
\r
5499 if ( !((input.LT(1).getText().equals("map"))) ) {
\r
5500 if (state.backtracking>0) {state.failed=true; return retval;}
\r
5501 throw new FailedPredicateException(input, "map", "input.LT(1).getText().equals(\"map\")");
\r
5503 ID148=(Token)match(input,ID,FOLLOW_ID_in_map3100); if (state.failed) return retval;
\r
5504 if ( state.backtracking==0 ) stream_ID.add(ID148);
\r
5506 LCURLY149=(Token)match(input,LCURLY,FOLLOW_LCURLY_in_map3102); if (state.failed) return retval;
\r
5507 if ( state.backtracking==0 ) stream_LCURLY.add(LCURLY149);
\r
5509 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:445:58: ( mapAssignment ( ',' mapAssignment )* )?
\r
5511 int LA48_0 = input.LA(1);
\r
5513 if ( (LA48_0==ID||LA48_0==LPAREN||LA48_0==LBRACKET||LA48_0==LCURLY||LA48_0==INT||LA48_0==FLOAT||LA48_0==STRING||(LA48_0>=79 && LA48_0<=80)) ) {
\r
5518 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:445:59: mapAssignment ( ',' mapAssignment )*
\r
5520 pushFollow(FOLLOW_mapAssignment_in_map3105);
\r
5521 mapAssignment150=mapAssignment();
\r
5524 if (state.failed) return retval;
\r
5525 if ( state.backtracking==0 ) stream_mapAssignment.add(mapAssignment150.getTree());
\r
5526 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:445:73: ( ',' mapAssignment )*
\r
5530 int LA47_0 = input.LA(1);
\r
5532 if ( (LA47_0==78) ) {
\r
5539 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:445:74: ',' mapAssignment
\r
5541 char_literal151=(Token)match(input,78,FOLLOW_78_in_map3108); if (state.failed) return retval;
\r
5542 if ( state.backtracking==0 ) stream_78.add(char_literal151);
\r
5544 pushFollow(FOLLOW_mapAssignment_in_map3110);
\r
5545 mapAssignment152=mapAssignment();
\r
5548 if (state.failed) return retval;
\r
5549 if ( state.backtracking==0 ) stream_mapAssignment.add(mapAssignment152.getTree());
\r
5565 RCURLY153=(Token)match(input,RCURLY,FOLLOW_RCURLY_in_map3116); if (state.failed) return retval;
\r
5566 if ( state.backtracking==0 ) stream_RCURLY.add(RCURLY153);
\r
5571 // elements: mapAssignment
\r
5573 // rule labels: retval
\r
5574 // token list labels:
\r
5575 // rule list labels:
\r
5576 // wildcard labels:
\r
5577 if ( state.backtracking==0 ) {
\r
5578 retval.tree = root_0;
\r
5579 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
5581 root_0 = (CommonTree)adaptor.nil();
\r
5582 // 446:5: -> ^( MAP ( mapAssignment )* )
\r
5584 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:446:8: ^( MAP ( mapAssignment )* )
\r
5586 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
5587 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(MAP, "MAP"), root_1);
\r
5589 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:446:14: ( mapAssignment )*
\r
5590 while ( stream_mapAssignment.hasNext() ) {
\r
5591 adaptor.addChild(root_1, stream_mapAssignment.nextTree());
\r
5594 stream_mapAssignment.reset();
\r
5596 adaptor.addChild(root_0, root_1);
\r
5601 retval.tree = root_0;}
\r
5604 retval.stop = input.LT(-1);
\r
5606 if ( state.backtracking==0 ) {
\r
5608 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
5609 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
5612 catch (RecognitionException re) {
\r
5614 recover(input,re);
\r
5615 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
5622 // $ANTLR end "map"
\r
5624 public static class mapAssignment_return extends ParserRuleReturnScope {
\r
5626 public Object getTree() { return tree; }
\r
5629 // $ANTLR start "mapAssignment"
\r
5630 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:449:1: mapAssignment : value '=' value -> ^( ASSIGNMENT ( value )* ) ;
\r
5631 public final GraphParser.mapAssignment_return mapAssignment() throws RecognitionException {
\r
5632 GraphParser.mapAssignment_return retval = new GraphParser.mapAssignment_return();
\r
5633 retval.start = input.LT(1);
\r
5635 CommonTree root_0 = null;
\r
5637 Token char_literal155=null;
\r
5638 GraphParser.value_return value154 = null;
\r
5640 GraphParser.value_return value156 = null;
\r
5643 CommonTree char_literal155_tree=null;
\r
5644 RewriteRuleTokenStream stream_74=new RewriteRuleTokenStream(adaptor,"token 74");
\r
5645 RewriteRuleSubtreeStream stream_value=new RewriteRuleSubtreeStream(adaptor,"rule value");
\r
5647 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:450:5: ( value '=' value -> ^( ASSIGNMENT ( value )* ) )
\r
5648 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:450:7: value '=' value
\r
5650 pushFollow(FOLLOW_value_in_mapAssignment3148);
\r
5654 if (state.failed) return retval;
\r
5655 if ( state.backtracking==0 ) stream_value.add(value154.getTree());
\r
5656 char_literal155=(Token)match(input,74,FOLLOW_74_in_mapAssignment3150); if (state.failed) return retval;
\r
5657 if ( state.backtracking==0 ) stream_74.add(char_literal155);
\r
5659 pushFollow(FOLLOW_value_in_mapAssignment3152);
\r
5663 if (state.failed) return retval;
\r
5664 if ( state.backtracking==0 ) stream_value.add(value156.getTree());
\r
5668 // elements: value
\r
5670 // rule labels: retval
\r
5671 // token list labels:
\r
5672 // rule list labels:
\r
5673 // wildcard labels:
\r
5674 if ( state.backtracking==0 ) {
\r
5675 retval.tree = root_0;
\r
5676 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
5678 root_0 = (CommonTree)adaptor.nil();
\r
5679 // 451:5: -> ^( ASSIGNMENT ( value )* )
\r
5681 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:451:8: ^( ASSIGNMENT ( value )* )
\r
5683 CommonTree root_1 = (CommonTree)adaptor.nil();
\r
5684 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ASSIGNMENT, "ASSIGNMENT"), root_1);
\r
5686 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:451:21: ( value )*
\r
5687 while ( stream_value.hasNext() ) {
\r
5688 adaptor.addChild(root_1, stream_value.nextTree());
\r
5691 stream_value.reset();
\r
5693 adaptor.addChild(root_0, root_1);
\r
5698 retval.tree = root_0;}
\r
5701 retval.stop = input.LT(-1);
\r
5703 if ( state.backtracking==0 ) {
\r
5705 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
\r
5706 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
5709 catch (RecognitionException re) {
\r
5711 recover(input,re);
\r
5712 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
5719 // $ANTLR end "mapAssignment"
\r
5721 // $ANTLR start synpred1_Graph
\r
5722 public final void synpred1_Graph_fragment() throws RecognitionException {
\r
5723 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:317:22: ( arrayType )
\r
5724 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:317:23: arrayType
\r
5726 pushFollow(FOLLOW_arrayType_in_synpred1_Graph2075);
\r
5730 if (state.failed) return ;
\r
5734 // $ANTLR end synpred1_Graph
\r
5736 // $ANTLR start synpred2_Graph
\r
5737 public final void synpred2_Graph_fragment() throws RecognitionException {
\r
5738 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:350:11: ( LPAREN )
\r
5739 // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:350:12: LPAREN
\r
5741 match(input,LPAREN,FOLLOW_LPAREN_in_synpred2_Graph2354); if (state.failed) return ;
\r
5745 // $ANTLR end synpred2_Graph
\r
5747 // Delegated rules
\r
5749 public final boolean synpred1_Graph() {
\r
5750 state.backtracking++;
\r
5751 int start = input.mark();
\r
5753 synpred1_Graph_fragment(); // can never throw exception
\r
5754 } catch (RecognitionException re) {
\r
5755 System.err.println("impossible: "+re);
\r
5757 boolean success = !state.failed;
\r
5758 input.rewind(start);
\r
5759 state.backtracking--;
\r
5760 state.failed=false;
\r
5763 public final boolean synpred2_Graph() {
\r
5764 state.backtracking++;
\r
5765 int start = input.mark();
\r
5767 synpred2_Graph_fragment(); // can never throw exception
\r
5768 } catch (RecognitionException re) {
\r
5769 System.err.println("impossible: "+re);
\r
5771 boolean success = !state.failed;
\r
5772 input.rewind(start);
\r
5773 state.backtracking--;
\r
5774 state.failed=false;
\r
5779 protected DFA13 dfa13 = new DFA13(this);
\r
5780 protected DFA22 dfa22 = new DFA22(this);
\r
5781 protected DFA31 dfa31 = new DFA31(this);
\r
5782 static final String DFA13_eotS =
\r
5784 static final String DFA13_eofS =
\r
5786 static final String DFA13_minS =
\r
5787 "\1\55\1\0\13\uffff";
\r
5788 static final String DFA13_maxS =
\r
5789 "\1\120\1\0\13\uffff";
\r
5790 static final String DFA13_acceptS =
\r
5791 "\2\uffff\1\2\11\uffff\1\1";
\r
5792 static final String DFA13_specialS =
\r
5793 "\1\uffff\1\0\13\uffff}>";
\r
5794 static final String[] DFA13_transitionS = {
\r
5795 "\1\1\2\uffff\1\2\1\uffff\1\2\1\uffff\1\2\1\uffff\1\2\1\uffff"+
\r
5796 "\1\2\4\uffff\2\2\14\uffff\2\2\2\uffff\2\2",
\r
5811 static final short[] DFA13_eot = DFA.unpackEncodedString(DFA13_eotS);
\r
5812 static final short[] DFA13_eof = DFA.unpackEncodedString(DFA13_eofS);
\r
5813 static final char[] DFA13_min = DFA.unpackEncodedStringToUnsignedChars(DFA13_minS);
\r
5814 static final char[] DFA13_max = DFA.unpackEncodedStringToUnsignedChars(DFA13_maxS);
\r
5815 static final short[] DFA13_accept = DFA.unpackEncodedString(DFA13_acceptS);
\r
5816 static final short[] DFA13_special = DFA.unpackEncodedString(DFA13_specialS);
\r
5817 static final short[][] DFA13_transition;
\r
5820 int numStates = DFA13_transitionS.length;
\r
5821 DFA13_transition = new short[numStates][];
\r
5822 for (int i=0; i<numStates; i++) {
\r
5823 DFA13_transition[i] = DFA.unpackEncodedString(DFA13_transitionS[i]);
\r
5827 class DFA13 extends DFA {
\r
5829 public DFA13(BaseRecognizer recognizer) {
\r
5830 this.recognizer = recognizer;
\r
5831 this.decisionNumber = 13;
\r
5832 this.eot = DFA13_eot;
\r
5833 this.eof = DFA13_eof;
\r
5834 this.min = DFA13_min;
\r
5835 this.max = DFA13_max;
\r
5836 this.accept = DFA13_accept;
\r
5837 this.special = DFA13_special;
\r
5838 this.transition = DFA13_transition;
\r
5840 public String getDescription() {
\r
5841 return "253:5: ({...}? => ID ( resource )+ INDENT resourceDefinitions DEDENT -> ^( TEMPLATE_DEFINITION ( resource )+ resourceDefinitions ) | ( resource )+ ( INDENT resourceDefinitions DEDENT )? -> ^( TEMPLATE_INSTANCE ( resource )+ ( resourceDefinitions )? ) )";
\r
5843 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
\r
5844 TokenStream input = (TokenStream)_input;
\r
5848 int LA13_1 = input.LA(1);
\r
5851 int index13_1 = input.index();
\r
5854 if ( ((input.LT(1).getText().equals("template"))) ) {s = 12;}
\r
5856 else if ( (true) ) {s = 2;}
\r
5859 input.seek(index13_1);
\r
5860 if ( s>=0 ) return s;
\r
5863 if (state.backtracking>0) {state.failed=true; return -1;}
\r
5864 NoViableAltException nvae =
\r
5865 new NoViableAltException(getDescription(), 13, _s, input);
\r
5870 static final String DFA22_eotS =
\r
5872 static final String DFA22_eofS =
\r
5874 static final String DFA22_minS =
\r
5875 "\1\55\2\uffff\1\0\10\uffff";
\r
5876 static final String DFA22_maxS =
\r
5877 "\1\116\2\uffff\1\0\10\uffff";
\r
5878 static final String DFA22_acceptS =
\r
5879 "\1\uffff\2\1\1\uffff\1\2\7\uffff";
\r
5880 static final String DFA22_specialS =
\r
5881 "\1\0\2\uffff\1\1\10\uffff}>";
\r
5882 static final String[] DFA22_transitionS = {
\r
5883 "\1\3\2\uffff\1\1\1\4\1\uffff\1\4\1\2\1\4\23\uffff\2\4\2\uffff"+
\r
5898 static final short[] DFA22_eot = DFA.unpackEncodedString(DFA22_eotS);
\r
5899 static final short[] DFA22_eof = DFA.unpackEncodedString(DFA22_eofS);
\r
5900 static final char[] DFA22_min = DFA.unpackEncodedStringToUnsignedChars(DFA22_minS);
\r
5901 static final char[] DFA22_max = DFA.unpackEncodedStringToUnsignedChars(DFA22_maxS);
\r
5902 static final short[] DFA22_accept = DFA.unpackEncodedString(DFA22_acceptS);
\r
5903 static final short[] DFA22_special = DFA.unpackEncodedString(DFA22_specialS);
\r
5904 static final short[][] DFA22_transition;
\r
5907 int numStates = DFA22_transitionS.length;
\r
5908 DFA22_transition = new short[numStates][];
\r
5909 for (int i=0; i<numStates; i++) {
\r
5910 DFA22_transition[i] = DFA.unpackEncodedString(DFA22_transitionS[i]);
\r
5914 class DFA22 extends DFA {
\r
5916 public DFA22(BaseRecognizer recognizer) {
\r
5917 this.recognizer = recognizer;
\r
5918 this.decisionNumber = 22;
\r
5919 this.eot = DFA22_eot;
\r
5920 this.eof = DFA22_eof;
\r
5921 this.min = DFA22_min;
\r
5922 this.max = DFA22_max;
\r
5923 this.accept = DFA22_accept;
\r
5924 this.special = DFA22_special;
\r
5925 this.transition = DFA22_transition;
\r
5927 public String getDescription() {
\r
5928 return "317:21: ( ( arrayType )=> arrayType )?";
\r
5930 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
\r
5931 TokenStream input = (TokenStream)_input;
\r
5935 int LA22_0 = input.LA(1);
\r
5938 int index22_0 = input.index();
\r
5941 if ( (LA22_0==LPAREN) && (synpred1_Graph())) {s = 1;}
\r
5943 else if ( (LA22_0==LCURLY) && (synpred1_Graph())) {s = 2;}
\r
5945 else if ( (LA22_0==ID) ) {s = 3;}
\r
5947 else if ( (LA22_0==EOF||LA22_0==RPAREN||LA22_0==RBRACKET||LA22_0==RCURLY||(LA22_0>=73 && LA22_0<=74)||(LA22_0>=77 && LA22_0<=78)) ) {s = 4;}
\r
5950 input.seek(index22_0);
\r
5951 if ( s>=0 ) return s;
\r
5954 int LA22_3 = input.LA(1);
\r
5957 int index22_3 = input.index();
\r
5960 if ( (synpred1_Graph()) ) {s = 2;}
\r
5962 else if ( (true) ) {s = 4;}
\r
5965 input.seek(index22_3);
\r
5966 if ( s>=0 ) return s;
\r
5969 if (state.backtracking>0) {state.failed=true; return -1;}
\r
5970 NoViableAltException nvae =
\r
5971 new NoViableAltException(getDescription(), 22, _s, input);
\r
5976 static final String DFA31_eotS =
\r
5978 static final String DFA31_eofS =
\r
5980 static final String DFA31_minS =
\r
5981 "\1\4\1\0\34\uffff";
\r
5982 static final String DFA31_maxS =
\r
5983 "\1\120\1\0\34\uffff";
\r
5984 static final String DFA31_acceptS =
\r
5985 "\2\uffff\1\2\32\uffff\1\1";
\r
5986 static final String DFA31_specialS =
\r
5987 "\1\uffff\1\0\34\uffff}>";
\r
5988 static final String[] DFA31_transitionS = {
\r
5989 "\2\2\47\uffff\1\2\2\uffff\1\1\6\2\1\uffff\1\2\1\uffff\1\2\2"+
\r
5990 "\uffff\2\2\4\uffff\16\2",
\r
6022 static final short[] DFA31_eot = DFA.unpackEncodedString(DFA31_eotS);
\r
6023 static final short[] DFA31_eof = DFA.unpackEncodedString(DFA31_eofS);
\r
6024 static final char[] DFA31_min = DFA.unpackEncodedStringToUnsignedChars(DFA31_minS);
\r
6025 static final char[] DFA31_max = DFA.unpackEncodedStringToUnsignedChars(DFA31_maxS);
\r
6026 static final short[] DFA31_accept = DFA.unpackEncodedString(DFA31_acceptS);
\r
6027 static final short[] DFA31_special = DFA.unpackEncodedString(DFA31_specialS);
\r
6028 static final short[][] DFA31_transition;
\r
6031 int numStates = DFA31_transitionS.length;
\r
6032 DFA31_transition = new short[numStates][];
\r
6033 for (int i=0; i<numStates; i++) {
\r
6034 DFA31_transition[i] = DFA.unpackEncodedString(DFA31_transitionS[i]);
\r
6038 class DFA31 extends DFA {
\r
6040 public DFA31(BaseRecognizer recognizer) {
\r
6041 this.recognizer = recognizer;
\r
6042 this.decisionNumber = 31;
\r
6043 this.eot = DFA31_eot;
\r
6044 this.eof = DFA31_eof;
\r
6045 this.min = DFA31_min;
\r
6046 this.max = DFA31_max;
\r
6047 this.accept = DFA31_accept;
\r
6048 this.special = DFA31_special;
\r
6049 this.transition = DFA31_transition;
\r
6051 public String getDescription() {
\r
6052 return "350:10: ( ( LPAREN )=> LPAREN parameter ( ',' parameter )* RPAREN )?";
\r
6054 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
\r
6055 TokenStream input = (TokenStream)_input;
\r
6059 int LA31_1 = input.LA(1);
\r
6062 int index31_1 = input.index();
\r
6065 if ( (synpred2_Graph()) ) {s = 29;}
\r
6067 else if ( (true) ) {s = 2;}
\r
6070 input.seek(index31_1);
\r
6071 if ( s>=0 ) return s;
\r
6074 if (state.backtracking>0) {state.failed=true; return -1;}
\r
6075 NoViableAltException nvae =
\r
6076 new NoViableAltException(getDescription(), 31, _s, input);
\r
6083 public static final BitSet FOLLOW_NEWLINE_in_file1230 = new BitSet(new long[]{0x6155200000000000L,0x0000000000019802L});
\r
6084 public static final BitSet FOLLOW_resourceDefinitions_in_file1233 = new BitSet(new long[]{0x0000000000000000L});
\r
6085 public static final BitSet FOLLOW_EOF_in_file1236 = new BitSet(new long[]{0x0000000000000002L});
\r
6086 public static final BitSet FOLLOW_resourceDefinition_in_resourceDefinitions1260 = new BitSet(new long[]{0x0400000000000002L});
\r
6087 public static final BitSet FOLLOW_NEWLINE_in_resourceDefinitions1263 = new BitSet(new long[]{0x6155200000000000L,0x0000000000019802L});
\r
6088 public static final BitSet FOLLOW_resourceDefinition_in_resourceDefinitions1266 = new BitSet(new long[]{0x0400000000000002L});
\r
6089 public static final BitSet FOLLOW_resource_in_resourceDefinition1300 = new BitSet(new long[]{0x4000200000000012L,0x0000000000000FF8L});
\r
6090 public static final BitSet FOLLOW_localProperty_in_resourceDefinition1308 = new BitSet(new long[]{0x4000200000000012L,0x0000000000000FF8L});
\r
6091 public static final BitSet FOLLOW_INDENT_in_resourceDefinition1318 = new BitSet(new long[]{0x6155200000000000L,0x0000000000019FFAL});
\r
6092 public static final BitSet FOLLOW_property_in_resourceDefinition1320 = new BitSet(new long[]{0x0400000000000020L});
\r
6093 public static final BitSet FOLLOW_NEWLINE_in_resourceDefinition1323 = new BitSet(new long[]{0x6155200000000000L,0x0000000000019FFAL});
\r
6094 public static final BitSet FOLLOW_property_in_resourceDefinition1325 = new BitSet(new long[]{0x0400000000000020L});
\r
6095 public static final BitSet FOLLOW_DEDENT_in_resourceDefinition1329 = new BitSet(new long[]{0x0000000000000002L});
\r
6096 public static final BitSet FOLLOW_template_in_resourceDefinition1358 = new BitSet(new long[]{0x0000000000000002L});
\r
6097 public static final BitSet FOLLOW_relation_in_localProperty1393 = new BitSet(new long[]{0x6155200000000000L,0x0000000000019800L});
\r
6098 public static final BitSet FOLLOW_resource_in_localProperty1395 = new BitSet(new long[]{0x0000000000000002L});
\r
6099 public static final BitSet FOLLOW_relation_in_property1434 = new BitSet(new long[]{0x6155200000000010L,0x0000000000019802L});
\r
6100 public static final BitSet FOLLOW_resourceDefinition_in_property1444 = new BitSet(new long[]{0x0000000000000002L});
\r
6101 public static final BitSet FOLLOW_INDENT_in_property1464 = new BitSet(new long[]{0x6155200000000000L,0x0000000000019802L});
\r
6102 public static final BitSet FOLLOW_resourceDefinitions_in_property1466 = new BitSet(new long[]{0x0000000000000020L});
\r
6103 public static final BitSet FOLLOW_DEDENT_in_property1468 = new BitSet(new long[]{0x0000000000000002L});
\r
6104 public static final BitSet FOLLOW_template_in_property1494 = new BitSet(new long[]{0x0000000000000002L});
\r
6105 public static final BitSet FOLLOW_65_in_template1515 = new BitSet(new long[]{0x6155200000000000L,0x0000000000019800L});
\r
6106 public static final BitSet FOLLOW_ID_in_template1533 = new BitSet(new long[]{0x6155200000000000L,0x0000000000019800L});
\r
6107 public static final BitSet FOLLOW_resource_in_template1535 = new BitSet(new long[]{0x6155200000000010L,0x0000000000019800L});
\r
6108 public static final BitSet FOLLOW_INDENT_in_template1545 = new BitSet(new long[]{0x6155200000000000L,0x0000000000019802L});
\r
6109 public static final BitSet FOLLOW_resourceDefinitions_in_template1547 = new BitSet(new long[]{0x0000000000000020L});
\r
6110 public static final BitSet FOLLOW_DEDENT_in_template1549 = new BitSet(new long[]{0x0000000000000002L});
\r
6111 public static final BitSet FOLLOW_resource_in_template1574 = new BitSet(new long[]{0x6155200000000012L,0x0000000000019800L});
\r
6112 public static final BitSet FOLLOW_INDENT_in_template1585 = new BitSet(new long[]{0x6155200000000000L,0x0000000000019802L});
\r
6113 public static final BitSet FOLLOW_resourceDefinitions_in_template1587 = new BitSet(new long[]{0x0000000000000020L});
\r
6114 public static final BitSet FOLLOW_DEDENT_in_template1589 = new BitSet(new long[]{0x0000000000000002L});
\r
6115 public static final BitSet FOLLOW_ID_in_relation1643 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});
\r
6116 public static final BitSet FOLLOW_66_in_relation1658 = new BitSet(new long[]{0x0000200000000000L});
\r
6117 public static final BitSet FOLLOW_ID_in_relation1660 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});
\r
6118 public static final BitSet FOLLOW_URI_in_relation1681 = new BitSet(new long[]{0x0000000000000002L});
\r
6119 public static final BitSet FOLLOW_67_in_relation1689 = new BitSet(new long[]{0x0000000000000002L});
\r
6120 public static final BitSet FOLLOW_68_in_relation1701 = new BitSet(new long[]{0x0000000000000002L});
\r
6121 public static final BitSet FOLLOW_69_in_relation1713 = new BitSet(new long[]{0x0000000000000002L});
\r
6122 public static final BitSet FOLLOW_70_in_relation1725 = new BitSet(new long[]{0x0000000000000002L});
\r
6123 public static final BitSet FOLLOW_71_in_relation1737 = new BitSet(new long[]{0x0000000000000002L});
\r
6124 public static final BitSet FOLLOW_72_in_relation1749 = new BitSet(new long[]{0x0000000000000002L});
\r
6125 public static final BitSet FOLLOW_73_in_relation1765 = new BitSet(new long[]{0x0000000000000002L});
\r
6126 public static final BitSet FOLLOW_74_in_relation1777 = new BitSet(new long[]{0x0000000000000002L});
\r
6127 public static final BitSet FOLLOW_75_in_relation1789 = new BitSet(new long[]{0x0000200000000000L});
\r
6128 public static final BitSet FOLLOW_ID_in_relation1791 = new BitSet(new long[]{0x0000000000000002L});
\r
6129 public static final BitSet FOLLOW_ID_in_resource1821 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});
\r
6130 public static final BitSet FOLLOW_ID_in_resource1840 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});
\r
6131 public static final BitSet FOLLOW_66_in_resource1855 = new BitSet(new long[]{0x2000200000000000L});
\r
6132 public static final BitSet FOLLOW_ID_in_resource1858 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});
\r
6133 public static final BitSet FOLLOW_STRING_in_resource1883 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});
\r
6134 public static final BitSet FOLLOW_URI_in_resource1924 = new BitSet(new long[]{0x0000000000000002L});
\r
6135 public static final BitSet FOLLOW_simpleValue_in_resource1932 = new BitSet(new long[]{0x0000000000000002L});
\r
6136 public static final BitSet FOLLOW_76_in_resource1948 = new BitSet(new long[]{0x0011200000000000L});
\r
6137 public static final BitSet FOLLOW_basicType_in_resource1950 = new BitSet(new long[]{0x0000000000000002L});
\r
6138 public static final BitSet FOLLOW_75_in_resource1966 = new BitSet(new long[]{0x0000200000000000L});
\r
6139 public static final BitSet FOLLOW_ID_in_resource1968 = new BitSet(new long[]{0x0000000000000002L});
\r
6140 public static final BitSet FOLLOW_arrayType_in_type2004 = new BitSet(new long[]{0x0000000000000002L});
\r
6141 public static final BitSet FOLLOW_unionType_in_type2012 = new BitSet(new long[]{0x0000000000000002L});
\r
6142 public static final BitSet FOLLOW_77_in_unionType2041 = new BitSet(new long[]{0x0000200000000000L});
\r
6143 public static final BitSet FOLLOW_unionComponent_in_unionType2043 = new BitSet(new long[]{0x0000000000000002L,0x0000000000002000L});
\r
6144 public static final BitSet FOLLOW_ID_in_unionComponent2071 = new BitSet(new long[]{0x0011200000000002L});
\r
6145 public static final BitSet FOLLOW_arrayType_in_unionComponent2080 = new BitSet(new long[]{0x0000000000000002L});
\r
6146 public static final BitSet FOLLOW_basicType_in_arrayType2108 = new BitSet(new long[]{0x0004000000000002L});
\r
6147 public static final BitSet FOLLOW_LBRACKET_in_arrayType2122 = new BitSet(new long[]{0x00C8000000000000L});
\r
6148 public static final BitSet FOLLOW_arrayLength_in_arrayType2124 = new BitSet(new long[]{0x0008000000000000L});
\r
6149 public static final BitSet FOLLOW_RBRACKET_in_arrayType2127 = new BitSet(new long[]{0x0004000000000002L});
\r
6150 public static final BitSet FOLLOW_set_in_arrayLength0 = new BitSet(new long[]{0x0000000000000002L});
\r
6151 public static final BitSet FOLLOW_tupleType_in_basicType2181 = new BitSet(new long[]{0x0000000000000002L});
\r
6152 public static final BitSet FOLLOW_recordType_in_basicType2189 = new BitSet(new long[]{0x0000000000000002L});
\r
6153 public static final BitSet FOLLOW_typeReference_in_basicType2197 = new BitSet(new long[]{0x0000000000000002L});
\r
6154 public static final BitSet FOLLOW_LPAREN_in_tupleType2219 = new BitSet(new long[]{0x0013200000000000L,0x0000000000002000L});
\r
6155 public static final BitSet FOLLOW_type_in_tupleType2222 = new BitSet(new long[]{0x0002000000000000L,0x0000000000004000L});
\r
6156 public static final BitSet FOLLOW_78_in_tupleType2225 = new BitSet(new long[]{0x0011200000000000L,0x0000000000002000L});
\r
6157 public static final BitSet FOLLOW_type_in_tupleType2227 = new BitSet(new long[]{0x0002000000000000L,0x0000000000004000L});
\r
6158 public static final BitSet FOLLOW_RPAREN_in_tupleType2233 = new BitSet(new long[]{0x0000000000000002L});
\r
6159 public static final BitSet FOLLOW_LCURLY_in_recordType2266 = new BitSet(new long[]{0x0020200000000000L});
\r
6160 public static final BitSet FOLLOW_component_in_recordType2269 = new BitSet(new long[]{0x0020000000000000L,0x0000000000004000L});
\r
6161 public static final BitSet FOLLOW_78_in_recordType2272 = new BitSet(new long[]{0x0000200000000000L});
\r
6162 public static final BitSet FOLLOW_component_in_recordType2274 = new BitSet(new long[]{0x0020000000000000L,0x0000000000004000L});
\r
6163 public static final BitSet FOLLOW_RCURLY_in_recordType2280 = new BitSet(new long[]{0x0000000000000002L});
\r
6164 public static final BitSet FOLLOW_ID_in_component2312 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L});
\r
6165 public static final BitSet FOLLOW_73_in_component2314 = new BitSet(new long[]{0x0011200000000000L,0x0000000000002000L});
\r
6166 public static final BitSet FOLLOW_type_in_component2316 = new BitSet(new long[]{0x0000000000000002L});
\r
6167 public static final BitSet FOLLOW_ID_in_typeReference2350 = new BitSet(new long[]{0x0001000000000002L});
\r
6168 public static final BitSet FOLLOW_LPAREN_in_typeReference2358 = new BitSet(new long[]{0x0011200000000000L,0x0000000000002000L});
\r
6169 public static final BitSet FOLLOW_parameter_in_typeReference2360 = new BitSet(new long[]{0x0002000000000000L,0x0000000000004000L});
\r
6170 public static final BitSet FOLLOW_78_in_typeReference2363 = new BitSet(new long[]{0x0011200000000000L,0x0000000000002000L});
\r
6171 public static final BitSet FOLLOW_parameter_in_typeReference2365 = new BitSet(new long[]{0x0002000000000000L,0x0000000000004000L});
\r
6172 public static final BitSet FOLLOW_RPAREN_in_typeReference2369 = new BitSet(new long[]{0x0000000000000002L});
\r
6173 public static final BitSet FOLLOW_ID_in_parameter2405 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L});
\r
6174 public static final BitSet FOLLOW_74_in_parameter2407 = new BitSet(new long[]{0x2145000000000000L,0x0000000000018000L});
\r
6175 public static final BitSet FOLLOW_parameterValue_in_parameter2409 = new BitSet(new long[]{0x0000000000000002L});
\r
6176 public static final BitSet FOLLOW_type_in_parameter2427 = new BitSet(new long[]{0x0000000000000002L});
\r
6177 public static final BitSet FOLLOW_string_in_parameterValue2446 = new BitSet(new long[]{0x0000000000000002L});
\r
6178 public static final BitSet FOLLOW_boolean__in_parameterValue2454 = new BitSet(new long[]{0x0000000000000002L});
\r
6179 public static final BitSet FOLLOW_number_in_parameterValue2462 = new BitSet(new long[]{0x0000000000000002L});
\r
6180 public static final BitSet FOLLOW_rangePar_in_parameterValue2470 = new BitSet(new long[]{0x0000000000000002L});
\r
6181 public static final BitSet FOLLOW_set_in_rangePar2499 = new BitSet(new long[]{0x03C0000000000000L});
\r
6182 public static final BitSet FOLLOW_range_in_rangePar2507 = new BitSet(new long[]{0x000A000000000000L});
\r
6183 public static final BitSet FOLLOW_set_in_rangePar2509 = new BitSet(new long[]{0x0000000000000002L});
\r
6184 public static final BitSet FOLLOW_number_in_range2536 = new BitSet(new long[]{0x0000000000000002L});
\r
6185 public static final BitSet FOLLOW_RANGE_in_range2544 = new BitSet(new long[]{0x0000000000000002L});
\r
6186 public static final BitSet FOLLOW_INT_RANGE_in_range2552 = new BitSet(new long[]{0x0000000000000002L});
\r
6187 public static final BitSet FOLLOW_set_in_number0 = new BitSet(new long[]{0x0000000000000002L});
\r
6188 public static final BitSet FOLLOW_STRING_in_string2606 = new BitSet(new long[]{0x0000000000000002L});
\r
6189 public static final BitSet FOLLOW_79_in_boolean_2627 = new BitSet(new long[]{0x0000000000000002L});
\r
6190 public static final BitSet FOLLOW_80_in_boolean_2639 = new BitSet(new long[]{0x0000000000000002L});
\r
6191 public static final BitSet FOLLOW_valueDefinition_in_valueDefinitions2660 = new BitSet(new long[]{0x0000200000000002L});
\r
6192 public static final BitSet FOLLOW_ID_in_valueDefinition2683 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L});
\r
6193 public static final BitSet FOLLOW_73_in_valueDefinition2685 = new BitSet(new long[]{0x0011200000000000L,0x0000000000002000L});
\r
6194 public static final BitSet FOLLOW_type_in_valueDefinition2687 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L});
\r
6195 public static final BitSet FOLLOW_74_in_valueDefinition2689 = new BitSet(new long[]{0x2155200000000000L,0x0000000000018000L});
\r
6196 public static final BitSet FOLLOW_value_in_valueDefinition2691 = new BitSet(new long[]{0x0000000000000002L});
\r
6197 public static final BitSet FOLLOW_basicValue_in_value2727 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000200L});
\r
6198 public static final BitSet FOLLOW_73_in_value2741 = new BitSet(new long[]{0x0011200000000000L,0x0000000000002000L});
\r
6199 public static final BitSet FOLLOW_type_in_value2743 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000200L});
\r
6200 public static final BitSet FOLLOW_simpleValue_in_basicValue2775 = new BitSet(new long[]{0x0000000000000002L});
\r
6201 public static final BitSet FOLLOW_map_in_basicValue2783 = new BitSet(new long[]{0x0000000000000002L});
\r
6202 public static final BitSet FOLLOW_ID_in_basicValue2793 = new BitSet(new long[]{0x0000000000000002L});
\r
6203 public static final BitSet FOLLOW_taggedValue_in_basicValue2805 = new BitSet(new long[]{0x0000000000000002L});
\r
6204 public static final BitSet FOLLOW_string_in_simpleValue2830 = new BitSet(new long[]{0x0000000000000002L});
\r
6205 public static final BitSet FOLLOW_number_in_simpleValue2838 = new BitSet(new long[]{0x0000000000000002L});
\r
6206 public static final BitSet FOLLOW_boolean__in_simpleValue2846 = new BitSet(new long[]{0x0000000000000002L});
\r
6207 public static final BitSet FOLLOW_array_in_simpleValue2854 = new BitSet(new long[]{0x0000000000000002L});
\r
6208 public static final BitSet FOLLOW_tuple_in_simpleValue2862 = new BitSet(new long[]{0x0000000000000002L});
\r
6209 public static final BitSet FOLLOW_record_in_simpleValue2870 = new BitSet(new long[]{0x0000000000000002L});
\r
6210 public static final BitSet FOLLOW_LBRACKET_in_array2891 = new BitSet(new long[]{0x215D200000000000L,0x0000000000018000L});
\r
6211 public static final BitSet FOLLOW_value_in_array2894 = new BitSet(new long[]{0x0008000000000000L,0x0000000000004000L});
\r
6212 public static final BitSet FOLLOW_78_in_array2897 = new BitSet(new long[]{0x2155200000000000L,0x0000000000018000L});
\r
6213 public static final BitSet FOLLOW_value_in_array2899 = new BitSet(new long[]{0x0008000000000000L,0x0000000000004000L});
\r
6214 public static final BitSet FOLLOW_RBRACKET_in_array2905 = new BitSet(new long[]{0x0000000000000002L});
\r
6215 public static final BitSet FOLLOW_LPAREN_in_tuple2937 = new BitSet(new long[]{0x2157200000000000L,0x0000000000018000L});
\r
6216 public static final BitSet FOLLOW_value_in_tuple2940 = new BitSet(new long[]{0x0002000000000000L,0x0000000000004000L});
\r
6217 public static final BitSet FOLLOW_78_in_tuple2943 = new BitSet(new long[]{0x2155200000000000L,0x0000000000018000L});
\r
6218 public static final BitSet FOLLOW_value_in_tuple2945 = new BitSet(new long[]{0x0002000000000000L,0x0000000000004000L});
\r
6219 public static final BitSet FOLLOW_RPAREN_in_tuple2951 = new BitSet(new long[]{0x0000000000000002L});
\r
6220 public static final BitSet FOLLOW_ID_in_taggedValue2983 = new BitSet(new long[]{0x2155000000000002L,0x0000000000018000L});
\r
6221 public static final BitSet FOLLOW_simpleValue_in_taggedValue2985 = new BitSet(new long[]{0x0000000000000002L});
\r
6222 public static final BitSet FOLLOW_LCURLY_in_record3020 = new BitSet(new long[]{0x0020200000000000L});
\r
6223 public static final BitSet FOLLOW_recordAssignment_in_record3023 = new BitSet(new long[]{0x0020000000000000L,0x0000000000004000L});
\r
6224 public static final BitSet FOLLOW_78_in_record3026 = new BitSet(new long[]{0x0000200000000000L});
\r
6225 public static final BitSet FOLLOW_recordAssignment_in_record3028 = new BitSet(new long[]{0x0020000000000000L,0x0000000000004000L});
\r
6226 public static final BitSet FOLLOW_RCURLY_in_record3034 = new BitSet(new long[]{0x0000000000000002L});
\r
6227 public static final BitSet FOLLOW_ID_in_recordAssignment3066 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L});
\r
6228 public static final BitSet FOLLOW_74_in_recordAssignment3068 = new BitSet(new long[]{0x2155200000000000L,0x0000000000018000L});
\r
6229 public static final BitSet FOLLOW_value_in_recordAssignment3070 = new BitSet(new long[]{0x0000000000000002L});
\r
6230 public static final BitSet FOLLOW_ID_in_map3100 = new BitSet(new long[]{0x0010000000000000L});
\r
6231 public static final BitSet FOLLOW_LCURLY_in_map3102 = new BitSet(new long[]{0x2175200000000000L,0x0000000000018000L});
\r
6232 public static final BitSet FOLLOW_mapAssignment_in_map3105 = new BitSet(new long[]{0x0020000000000000L,0x0000000000004000L});
\r
6233 public static final BitSet FOLLOW_78_in_map3108 = new BitSet(new long[]{0x2155200000000000L,0x0000000000018000L});
\r
6234 public static final BitSet FOLLOW_mapAssignment_in_map3110 = new BitSet(new long[]{0x0020000000000000L,0x0000000000004000L});
\r
6235 public static final BitSet FOLLOW_RCURLY_in_map3116 = new BitSet(new long[]{0x0000000000000002L});
\r
6236 public static final BitSet FOLLOW_value_in_mapAssignment3148 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L});
\r
6237 public static final BitSet FOLLOW_74_in_mapAssignment3150 = new BitSet(new long[]{0x2155200000000000L,0x0000000000018000L});
\r
6238 public static final BitSet FOLLOW_value_in_mapAssignment3152 = new BitSet(new long[]{0x0000000000000002L});
\r
6239 public static final BitSet FOLLOW_arrayType_in_synpred1_Graph2075 = new BitSet(new long[]{0x0000000000000002L});
\r
6240 public static final BitSet FOLLOW_LPAREN_in_synpred2_Graph2354 = new BitSet(new long[]{0x0000000000000002L});
\r