bundles/org.simantics.graph.compiler/src/org/simantics/graph/compiler/internal/parsing/GraphParser.java

   1 // $ANTLR 3.5.2 src/org/simantics/graph/compiler/internal/parsing/Graph.g 2018-06-15 14:02:54
   2  package org.simantics.graph.compiler.internal.parsing;
   3
   4 import org.antlr.runtime.*;
   5 import java.util.Stack;
   6 import java.util.List;
   7 import java.util.ArrayList;
   8 import java.util.Map;
   9 import java.util.HashMap;
  10
  11 import org.antlr.runtime.tree.*;
  12
  13
  14 @SuppressWarnings("all")
  15 public class GraphParser extends Parser {
  16         public static final String[] tokenNames = new String[] {
  17                 "<invalid>", "<EOR>", "<DOWN>", "<UP>", "ARRAY", "ARRAY_TYPE", "ASSIGNMENT",
  18                 "BLANK", "COMMENT", "DEDENT", "DOMAIN_OF", "EMBEDDED_TYPE", "EMBEDDED_VALUE",
  19                 "EQUALS", "ESC_SEQ", "EXPONENT", "FALSE", "FILE", "FLOAT", "HAS_DOMAIN",
  20                 "HAS_RANGE", "HEX_DIGIT", "ID", "INDENT", "INHERITS", "INSTANCE_OF", "INT",
  21                 "INT_RANGE", "LBRACKET", "LCURLY", "LPAREN", "MAP", "NEWLINE", "NO_VALUE",
  22                 "PROPERTY", "RANGE", "RBRACKET", "RCURLY", "RECORD", "RECORD_TYPE", "REF",
  23                 "REQUIRES_VALUE_TYPE", "RESOURCE", "RPAREN", "STRING", "SUBRELATION_OF",
  24                 "TAGGED_VALUE", "TEMPLATE_DEFINITION", "TEMPLATE_INSTANCE", "TRUE", "TUPLE",
  25                 "TUPLE_TYPE", "TYPE_ANNOTATION", "TYPE_COMPONENT", "TYPE_DEFINITION",
  26                 "TYPE_DEFINITIONS", "TYPE_REFERENCE", "UNICODE_ESC", "UNION_TYPE", "URI",
  27                 "VALUE_DEFINITION", "VALUE_DEFINITIONS", "VARIABLE", "VARIANT", "WS",
  28                 "'$'", "'%'", "','", "'-->'", "'.'", "':'", "'<--'", "'<R'", "'<T'", "'='",
  29                 "'==>'", "'>--'", "'@'", "'false'", "'true'", "'|'"
  30         };
  31         public static final int EOF=-1;
  32         public static final int T__65=65;
  33         public static final int T__66=66;
  34         public static final int T__67=67;
  35         public static final int T__68=68;
  36         public static final int T__69=69;
  37         public static final int T__70=70;
  38         public static final int T__71=71;
  39         public static final int T__72=72;
  40         public static final int T__73=73;
  41         public static final int T__74=74;
  42         public static final int T__75=75;
  43         public static final int T__76=76;
  44         public static final int T__77=77;
  45         public static final int T__78=78;
  46         public static final int T__79=79;
  47         public static final int T__80=80;
  48         public static final int ARRAY=4;
  49         public static final int ARRAY_TYPE=5;
  50         public static final int ASSIGNMENT=6;
  51         public static final int BLANK=7;
  52         public static final int COMMENT=8;
  53         public static final int DEDENT=9;
  54         public static final int DOMAIN_OF=10;
  55         public static final int EMBEDDED_TYPE=11;
  56         public static final int EMBEDDED_VALUE=12;
  57         public static final int EQUALS=13;
  58         public static final int ESC_SEQ=14;
  59         public static final int EXPONENT=15;
  60         public static final int FALSE=16;
  61         public static final int FILE=17;
  62         public static final int FLOAT=18;
  63         public static final int HAS_DOMAIN=19;
  64         public static final int HAS_RANGE=20;
  65         public static final int HEX_DIGIT=21;
  66         public static final int ID=22;
  67         public static final int INDENT=23;
  68         public static final int INHERITS=24;
  69         public static final int INSTANCE_OF=25;
  70         public static final int INT=26;
  71         public static final int INT_RANGE=27;
  72         public static final int LBRACKET=28;
  73         public static final int LCURLY=29;
  74         public static final int LPAREN=30;
  75         public static final int MAP=31;
  76         public static final int NEWLINE=32;
  77         public static final int NO_VALUE=33;
  78         public static final int PROPERTY=34;
  79         public static final int RANGE=35;
  80         public static final int RBRACKET=36;
  81         public static final int RCURLY=37;
  82         public static final int RECORD=38;
  83         public static final int RECORD_TYPE=39;
  84         public static final int REF=40;
  85         public static final int REQUIRES_VALUE_TYPE=41;
  86         public static final int RESOURCE=42;
  87         public static final int RPAREN=43;
  88         public static final int STRING=44;
  89         public static final int SUBRELATION_OF=45;
  90         public static final int TAGGED_VALUE=46;
  91         public static final int TEMPLATE_DEFINITION=47;
  92         public static final int TEMPLATE_INSTANCE=48;
  93         public static final int TRUE=49;
  94         public static final int TUPLE=50;
  95         public static final int TUPLE_TYPE=51;
  96         public static final int TYPE_ANNOTATION=52;
  97         public static final int TYPE_COMPONENT=53;
  98         public static final int TYPE_DEFINITION=54;
  99         public static final int TYPE_DEFINITIONS=55;
 100         public static final int TYPE_REFERENCE=56;
 101         public static final int UNICODE_ESC=57;
 102         public static final int UNION_TYPE=58;
 103         public static final int URI=59;
 104         public static final int VALUE_DEFINITION=60;
 105         public static final int VALUE_DEFINITIONS=61;
 106         public static final int VARIABLE=62;
 107         public static final int VARIANT=63;
 108         public static final int WS=64;
 109
 110         // delegates
 111         public Parser[] getDelegates() {
 112                 return new Parser[] {};
 113         }
 114
 115         // delegators
 116
 117
 118         public GraphParser(TokenStream input) {
 119                 this(input, new RecognizerSharedState());
 120         }
 121         public GraphParser(TokenStream input, RecognizerSharedState state) {
 122                 super(input, state);
 123         }
 124
 125         protected TreeAdaptor adaptor = new CommonTreeAdaptor();
 126
 127         public void setTreeAdaptor(TreeAdaptor adaptor) {
 128                 this.adaptor = adaptor;
 129         }
 130         public TreeAdaptor getTreeAdaptor() {
 131                 return adaptor;
 132         }
 133         @Override public String[] getTokenNames() { return GraphParser.tokenNames; }
 134         @Override public String getGrammarFileName() { return "src/org/simantics/graph/compiler/internal/parsing/Graph.g"; }
 135
 136
 137         public static class file_return extends ParserRuleReturnScope {
 138                 CommonTree tree;
 139                 @Override
 140                 public CommonTree getTree() { return tree; }
 141         };
 142
 143
 144         // $ANTLR start "file"
 145         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:224:1: file : ( NEWLINE )? ( resourceDefinitions )? EOF -> ^( FILE ( resourceDefinitions )? ) ;
 146         public final GraphParser.file_return file() throws RecognitionException {
 147                 GraphParser.file_return retval = new GraphParser.file_return();
 148                 retval.start = input.LT(1);
 149
 150                 CommonTree root_0 = null;
 151
 152                 Token NEWLINE1=null;
 153                 Token EOF3=null;
 154                 ParserRuleReturnScope resourceDefinitions2 =null;
 155
 156                 CommonTree NEWLINE1_tree=null;
 157                 CommonTree EOF3_tree=null;
 158                 RewriteRuleTokenStream stream_NEWLINE=new RewriteRuleTokenStream(adaptor,"token NEWLINE");
 159                 RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
 160                 RewriteRuleSubtreeStream stream_resourceDefinitions=new RewriteRuleSubtreeStream(adaptor,"rule resourceDefinitions");
 161
 162                 try {
 163                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:224:6: ( ( NEWLINE )? ( resourceDefinitions )? EOF -> ^( FILE ( resourceDefinitions )? ) )
 164                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:224:8: ( NEWLINE )? ( resourceDefinitions )? EOF
 165                         {
 166                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:224:8: ( NEWLINE )?
 167                         int alt1=2;
 168                         int LA1_0 = input.LA(1);
 169                         if ( (LA1_0==NEWLINE) ) {
 170                                 alt1=1;
 171                         }
 172                         switch (alt1) {
 173                                 case 1 :
 174                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:224:8: NEWLINE
 175                                         {
 176                                         NEWLINE1=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_file1230); if (state.failed) return retval;
 177                                         if ( state.backtracking==0 ) stream_NEWLINE.add(NEWLINE1);
 178
 179                                         }
 180                                         break;
 181
 182                         }
 183
 184                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:224:17: ( resourceDefinitions )?
 185                         int alt2=2;
 186                         int LA2_0 = input.LA(1);
 187                         if ( (LA2_0==FLOAT||LA2_0==ID||LA2_0==INT||(LA2_0 >= LBRACKET && LA2_0 <= LPAREN)||LA2_0==STRING||LA2_0==URI||(LA2_0 >= 65 && LA2_0 <= 66)||(LA2_0 >= 77 && LA2_0 <= 79)) ) {
 188                                 alt2=1;
 189                         }
 190                         switch (alt2) {
 191                                 case 1 :
 192                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:224:17: resourceDefinitions
 193                                         {
 194                                         pushFollow(FOLLOW_resourceDefinitions_in_file1233);
 195                                         resourceDefinitions2=resourceDefinitions();
 196                                         state._fsp--;
 197                                         if (state.failed) return retval;
 198                                         if ( state.backtracking==0 ) stream_resourceDefinitions.add(resourceDefinitions2.getTree());
 199                                         }
 200                                         break;
 201
 202                         }
 203
 204                         EOF3=(Token)match(input,EOF,FOLLOW_EOF_in_file1236); if (state.failed) return retval;
 205                         if ( state.backtracking==0 ) stream_EOF.add(EOF3);
 206
 207                         // AST REWRITE
 208                         // elements: resourceDefinitions
 209                         // token labels:
 210                         // rule labels: retval
 211                         // token list labels:
 212                         // rule list labels:
 213                         // wildcard labels:
 214                         if ( state.backtracking==0 ) {
 215                         retval.tree = root_0;
 216                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
 217
 218                         root_0 = (CommonTree)adaptor.nil();
 219                         // 224:42: -> ^( FILE ( resourceDefinitions )? )
 220                         {
 221                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:224:45: ^( FILE ( resourceDefinitions )? )
 222                                 {
 223                                 CommonTree root_1 = (CommonTree)adaptor.nil();
 224                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(FILE, "FILE"), root_1);
 225                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:224:52: ( resourceDefinitions )?
 226                                 if ( stream_resourceDefinitions.hasNext() ) {
 227                                         adaptor.addChild(root_1, stream_resourceDefinitions.nextTree());
 228                                 }
 229                                 stream_resourceDefinitions.reset();
 230
 231                                 adaptor.addChild(root_0, root_1);
 232                                 }
 233
 234                         }
 235
 236
 237                         retval.tree = root_0;
 238                         }
 239
 240                         }
 241
 242                         retval.stop = input.LT(-1);
 243
 244                         if ( state.backtracking==0 ) {
 245                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 246                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 247                         }
 248                 }
 249                 catch (RecognitionException re) {
 250                         reportError(re);
 251                         recover(input,re);
 252                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 253                 }
 254                 finally {
 255                         // do for sure before leaving
 256                 }
 257                 return retval;
 258         }
 259         // $ANTLR end "file"
 260
 261
 262         public static class resourceDefinitions_return extends ParserRuleReturnScope {
 263                 CommonTree tree;
 264                 @Override
 265                 public CommonTree getTree() { return tree; }
 266         };
 267
 268
 269         // $ANTLR start "resourceDefinitions"
 270         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:226:1: resourceDefinitions : resourceDefinition ( NEWLINE ! resourceDefinition )* ;
 271         public final GraphParser.resourceDefinitions_return resourceDefinitions() throws RecognitionException {
 272                 GraphParser.resourceDefinitions_return retval = new GraphParser.resourceDefinitions_return();
 273                 retval.start = input.LT(1);
 274
 275                 CommonTree root_0 = null;
 276
 277                 Token NEWLINE5=null;
 278                 ParserRuleReturnScope resourceDefinition4 =null;
 279                 ParserRuleReturnScope resourceDefinition6 =null;
 280
 281                 CommonTree NEWLINE5_tree=null;
 282
 283                 try {
 284                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:227:6: ( resourceDefinition ( NEWLINE ! resourceDefinition )* )
 285                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:227:8: resourceDefinition ( NEWLINE ! resourceDefinition )*
 286                         {
 287                         root_0 = (CommonTree)adaptor.nil();
 288
 289
 290                         pushFollow(FOLLOW_resourceDefinition_in_resourceDefinitions1260);
 291                         resourceDefinition4=resourceDefinition();
 292                         state._fsp--;
 293                         if (state.failed) return retval;
 294                         if ( state.backtracking==0 ) adaptor.addChild(root_0, resourceDefinition4.getTree());
 295
 296                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:227:27: ( NEWLINE ! resourceDefinition )*
 297                         loop3:
 298                         while (true) {
 299                                 int alt3=2;
 300                                 int LA3_0 = input.LA(1);
 301                                 if ( (LA3_0==NEWLINE) ) {
 302                                         alt3=1;
 303                                 }
 304
 305                                 switch (alt3) {
 306                                 case 1 :
 307                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:227:28: NEWLINE ! resourceDefinition
 308                                         {
 309                                         NEWLINE5=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_resourceDefinitions1263); if (state.failed) return retval;
 310                                         pushFollow(FOLLOW_resourceDefinition_in_resourceDefinitions1266);
 311                                         resourceDefinition6=resourceDefinition();
 312                                         state._fsp--;
 313                                         if (state.failed) return retval;
 314                                         if ( state.backtracking==0 ) adaptor.addChild(root_0, resourceDefinition6.getTree());
 315
 316                                         }
 317                                         break;
 318
 319                                 default :
 320                                         break loop3;
 321                                 }
 322                         }
 323
 324                         }
 325
 326                         retval.stop = input.LT(-1);
 327
 328                         if ( state.backtracking==0 ) {
 329                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 330                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 331                         }
 332                 }
 333                 catch (RecognitionException re) {
 334                         reportError(re);
 335                         recover(input,re);
 336                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 337                 }
 338                 finally {
 339                         // do for sure before leaving
 340                 }
 341                 return retval;
 342         }
 343         // $ANTLR end "resourceDefinitions"
 344
 345
 346         public static class resourceDefinition_return extends ParserRuleReturnScope {
 347                 CommonTree tree;
 348                 @Override
 349                 public CommonTree getTree() { return tree; }
 350         };
 351
 352
 353         // $ANTLR start "resourceDefinition"
 354         // 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 ) );
 355         public final GraphParser.resourceDefinition_return resourceDefinition() throws RecognitionException {
 356                 GraphParser.resourceDefinition_return retval = new GraphParser.resourceDefinition_return();
 357                 retval.start = input.LT(1);
 358
 359                 CommonTree root_0 = null;
 360
 361                 Token INDENT9=null;
 362                 Token NEWLINE11=null;
 363                 Token DEDENT13=null;
 364                 ParserRuleReturnScope resource7 =null;
 365                 ParserRuleReturnScope localProperty8 =null;
 366                 ParserRuleReturnScope property10 =null;
 367                 ParserRuleReturnScope property12 =null;
 368                 ParserRuleReturnScope template14 =null;
 369
 370                 CommonTree INDENT9_tree=null;
 371                 CommonTree NEWLINE11_tree=null;
 372                 CommonTree DEDENT13_tree=null;
 373                 RewriteRuleTokenStream stream_INDENT=new RewriteRuleTokenStream(adaptor,"token INDENT");
 374                 RewriteRuleTokenStream stream_NEWLINE=new RewriteRuleTokenStream(adaptor,"token NEWLINE");
 375                 RewriteRuleTokenStream stream_DEDENT=new RewriteRuleTokenStream(adaptor,"token DEDENT");
 376                 RewriteRuleSubtreeStream stream_template=new RewriteRuleSubtreeStream(adaptor,"rule template");
 377                 RewriteRuleSubtreeStream stream_resource=new RewriteRuleSubtreeStream(adaptor,"rule resource");
 378                 RewriteRuleSubtreeStream stream_property=new RewriteRuleSubtreeStream(adaptor,"rule property");
 379                 RewriteRuleSubtreeStream stream_localProperty=new RewriteRuleSubtreeStream(adaptor,"rule localProperty");
 380
 381                 try {
 382                         // 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 ) )
 383                         int alt7=2;
 384                         int LA7_0 = input.LA(1);
 385                         if ( (LA7_0==FLOAT||LA7_0==ID||LA7_0==INT||(LA7_0 >= LBRACKET && LA7_0 <= LPAREN)||LA7_0==STRING||LA7_0==URI||(LA7_0 >= 65 && LA7_0 <= 66)||(LA7_0 >= 78 && LA7_0 <= 79)) ) {
 386                                 alt7=1;
 387                         }
 388                         else if ( (LA7_0==77) ) {
 389                                 alt7=2;
 390                         }
 391
 392                         else {
 393                                 if (state.backtracking>0) {state.failed=true; return retval;}
 394                                 NoViableAltException nvae =
 395                                         new NoViableAltException("", 7, 0, input);
 396                                 throw nvae;
 397                         }
 398
 399                         switch (alt7) {
 400                                 case 1 :
 401                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:231:7: resource ( localProperty )* ( INDENT property ( NEWLINE property )* DEDENT )?
 402                                         {
 403                                         pushFollow(FOLLOW_resource_in_resourceDefinition1300);
 404                                         resource7=resource();
 405                                         state._fsp--;
 406                                         if (state.failed) return retval;
 407                                         if ( state.backtracking==0 ) stream_resource.add(resource7.getTree());
 408                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:232:7: ( localProperty )*
 409                                         loop4:
 410                                         while (true) {
 411                                                 int alt4=2;
 412                                                 int LA4_0 = input.LA(1);
 413                                                 if ( (LA4_0==ID||LA4_0==URI||LA4_0==66||LA4_0==68||(LA4_0 >= 70 && LA4_0 <= 76)) ) {
 414                                                         alt4=1;
 415                                                 }
 416
 417                                                 switch (alt4) {
 418                                                 case 1 :
 419                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:232:7: localProperty
 420                                                         {
 421                                                         pushFollow(FOLLOW_localProperty_in_resourceDefinition1308);
 422                                                         localProperty8=localProperty();
 423                                                         state._fsp--;
 424                                                         if (state.failed) return retval;
 425                                                         if ( state.backtracking==0 ) stream_localProperty.add(localProperty8.getTree());
 426                                                         }
 427                                                         break;
 428
 429                                                 default :
 430                                                         break loop4;
 431                                                 }
 432                                         }
 433
 434                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:233:7: ( INDENT property ( NEWLINE property )* DEDENT )?
 435                                         int alt6=2;
 436                                         int LA6_0 = input.LA(1);
 437                                         if ( (LA6_0==INDENT) ) {
 438                                                 alt6=1;
 439                                         }
 440                                         switch (alt6) {
 441                                                 case 1 :
 442                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:233:8: INDENT property ( NEWLINE property )* DEDENT
 443                                                         {
 444                                                         INDENT9=(Token)match(input,INDENT,FOLLOW_INDENT_in_resourceDefinition1318); if (state.failed) return retval;
 445                                                         if ( state.backtracking==0 ) stream_INDENT.add(INDENT9);
 446
 447                                                         pushFollow(FOLLOW_property_in_resourceDefinition1320);
 448                                                         property10=property();
 449                                                         state._fsp--;
 450                                                         if (state.failed) return retval;
 451                                                         if ( state.backtracking==0 ) stream_property.add(property10.getTree());
 452                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:233:24: ( NEWLINE property )*
 453                                                         loop5:
 454                                                         while (true) {
 455                                                                 int alt5=2;
 456                                                                 int LA5_0 = input.LA(1);
 457                                                                 if ( (LA5_0==NEWLINE) ) {
 458                                                                         alt5=1;
 459                                                                 }
 460
 461                                                                 switch (alt5) {
 462                                                                 case 1 :
 463                                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:233:25: NEWLINE property
 464                                                                         {
 465                                                                         NEWLINE11=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_resourceDefinition1323); if (state.failed) return retval;
 466                                                                         if ( state.backtracking==0 ) stream_NEWLINE.add(NEWLINE11);
 467
 468                                                                         pushFollow(FOLLOW_property_in_resourceDefinition1325);
 469                                                                         property12=property();
 470                                                                         state._fsp--;
 471                                                                         if (state.failed) return retval;
 472                                                                         if ( state.backtracking==0 ) stream_property.add(property12.getTree());
 473                                                                         }
 474                                                                         break;
 475
 476                                                                 default :
 477                                                                         break loop5;
 478                                                                 }
 479                                                         }
 480
 481                                                         DEDENT13=(Token)match(input,DEDENT,FOLLOW_DEDENT_in_resourceDefinition1329); if (state.failed) return retval;
 482                                                         if ( state.backtracking==0 ) stream_DEDENT.add(DEDENT13);
 483
 484                                                         }
 485                                                         break;
 486
 487                                         }
 488
 489                                         // AST REWRITE
 490                                         // elements: localProperty, resource, property
 491                                         // token labels:
 492                                         // rule labels: retval
 493                                         // token list labels:
 494                                         // rule list labels:
 495                                         // wildcard labels:
 496                                         if ( state.backtracking==0 ) {
 497                                         retval.tree = root_0;
 498                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
 499
 500                                         root_0 = (CommonTree)adaptor.nil();
 501                                         // 234:5: -> ^( RESOURCE resource ( localProperty )* ( property )* )
 502                                         {
 503                                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:234:8: ^( RESOURCE resource ( localProperty )* ( property )* )
 504                                                 {
 505                                                 CommonTree root_1 = (CommonTree)adaptor.nil();
 506                                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(RESOURCE, "RESOURCE"), root_1);
 507                                                 adaptor.addChild(root_1, stream_resource.nextTree());
 508                                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:234:28: ( localProperty )*
 509                                                 while ( stream_localProperty.hasNext() ) {
 510                                                         adaptor.addChild(root_1, stream_localProperty.nextTree());
 511                                                 }
 512                                                 stream_localProperty.reset();
 513
 514                                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:234:43: ( property )*
 515                                                 while ( stream_property.hasNext() ) {
 516                                                         adaptor.addChild(root_1, stream_property.nextTree());
 517                                                 }
 518                                                 stream_property.reset();
 519
 520                                                 adaptor.addChild(root_0, root_1);
 521                                                 }
 522
 523                                         }
 524
 525
 526                                         retval.tree = root_0;
 527                                         }
 528
 529                                         }
 530                                         break;
 531                                 case 2 :
 532                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:235:7: template
 533                                         {
 534                                         pushFollow(FOLLOW_template_in_resourceDefinition1358);
 535                                         template14=template();
 536                                         state._fsp--;
 537                                         if (state.failed) return retval;
 538                                         if ( state.backtracking==0 ) stream_template.add(template14.getTree());
 539                                         // AST REWRITE
 540                                         // elements: template, template
 541                                         // token labels:
 542                                         // rule labels: retval
 543                                         // token list labels:
 544                                         // rule list labels:
 545                                         // wildcard labels:
 546                                         if ( state.backtracking==0 ) {
 547                                         retval.tree = root_0;
 548                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
 549
 550                                         root_0 = (CommonTree)adaptor.nil();
 551                                         // 235:16: -> ^( RESOURCE ^( BLANK template ) template )
 552                                         {
 553                                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:235:19: ^( RESOURCE ^( BLANK template ) template )
 554                                                 {
 555                                                 CommonTree root_1 = (CommonTree)adaptor.nil();
 556                                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(RESOURCE, "RESOURCE"), root_1);
 557                                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:235:30: ^( BLANK template )
 558                                                 {
 559                                                 CommonTree root_2 = (CommonTree)adaptor.nil();
 560                                                 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(BLANK, "BLANK"), root_2);
 561                                                 adaptor.addChild(root_2, stream_template.nextTree());
 562                                                 adaptor.addChild(root_1, root_2);
 563                                                 }
 564
 565                                                 adaptor.addChild(root_1, stream_template.nextTree());
 566                                                 adaptor.addChild(root_0, root_1);
 567                                                 }
 568
 569                                         }
 570
 571
 572                                         retval.tree = root_0;
 573                                         }
 574
 575                                         }
 576                                         break;
 577
 578                         }
 579                         retval.stop = input.LT(-1);
 580
 581                         if ( state.backtracking==0 ) {
 582                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 583                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 584                         }
 585                 }
 586                 catch (RecognitionException re) {
 587                         reportError(re);
 588                         recover(input,re);
 589                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 590                 }
 591                 finally {
 592                         // do for sure before leaving
 593                 }
 594                 return retval;
 595         }
 596         // $ANTLR end "resourceDefinition"
 597
 598
 599         public static class localProperty_return extends ParserRuleReturnScope {
 600                 CommonTree tree;
 601                 @Override
 602                 public CommonTree getTree() { return tree; }
 603         };
 604
 605
 606         // $ANTLR start "localProperty"
 607         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:238:1: localProperty : relation resource -> ^( PROPERTY relation ^( RESOURCE resource ) ) ;
 608         public final GraphParser.localProperty_return localProperty() throws RecognitionException {
 609                 GraphParser.localProperty_return retval = new GraphParser.localProperty_return();
 610                 retval.start = input.LT(1);
 611
 612                 CommonTree root_0 = null;
 613
 614                 ParserRuleReturnScope relation15 =null;
 615                 ParserRuleReturnScope resource16 =null;
 616
 617                 RewriteRuleSubtreeStream stream_resource=new RewriteRuleSubtreeStream(adaptor,"rule resource");
 618                 RewriteRuleSubtreeStream stream_relation=new RewriteRuleSubtreeStream(adaptor,"rule relation");
 619
 620                 try {
 621                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:239:5: ( relation resource -> ^( PROPERTY relation ^( RESOURCE resource ) ) )
 622                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:239:7: relation resource
 623                         {
 624                         pushFollow(FOLLOW_relation_in_localProperty1393);
 625                         relation15=relation();
 626                         state._fsp--;
 627                         if (state.failed) return retval;
 628                         if ( state.backtracking==0 ) stream_relation.add(relation15.getTree());
 629                         pushFollow(FOLLOW_resource_in_localProperty1395);
 630                         resource16=resource();
 631                         state._fsp--;
 632                         if (state.failed) return retval;
 633                         if ( state.backtracking==0 ) stream_resource.add(resource16.getTree());
 634                         // AST REWRITE
 635                         // elements: relation, resource
 636                         // token labels:
 637                         // rule labels: retval
 638                         // token list labels:
 639                         // rule list labels:
 640                         // wildcard labels:
 641                         if ( state.backtracking==0 ) {
 642                         retval.tree = root_0;
 643                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
 644
 645                         root_0 = (CommonTree)adaptor.nil();
 646                         // 240:5: -> ^( PROPERTY relation ^( RESOURCE resource ) )
 647                         {
 648                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:240:8: ^( PROPERTY relation ^( RESOURCE resource ) )
 649                                 {
 650                                 CommonTree root_1 = (CommonTree)adaptor.nil();
 651                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(PROPERTY, "PROPERTY"), root_1);
 652                                 adaptor.addChild(root_1, stream_relation.nextTree());
 653                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:240:28: ^( RESOURCE resource )
 654                                 {
 655                                 CommonTree root_2 = (CommonTree)adaptor.nil();
 656                                 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(RESOURCE, "RESOURCE"), root_2);
 657                                 adaptor.addChild(root_2, stream_resource.nextTree());
 658                                 adaptor.addChild(root_1, root_2);
 659                                 }
 660
 661                                 adaptor.addChild(root_0, root_1);
 662                                 }
 663
 664                         }
 665
 666
 667                         retval.tree = root_0;
 668                         }
 669
 670                         }
 671
 672                         retval.stop = input.LT(-1);
 673
 674                         if ( state.backtracking==0 ) {
 675                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 676                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 677                         }
 678                 }
 679                 catch (RecognitionException re) {
 680                         reportError(re);
 681                         recover(input,re);
 682                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 683                 }
 684                 finally {
 685                         // do for sure before leaving
 686                 }
 687                 return retval;
 688         }
 689         // $ANTLR end "localProperty"
 690
 691
 692         public static class property_return extends ParserRuleReturnScope {
 693                 CommonTree tree;
 694                 @Override
 695                 public CommonTree getTree() { return tree; }
 696         };
 697
 698
 699         // $ANTLR start "property"
 700         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:243:1: property : ( relation ( resourceDefinition -> ^( PROPERTY relation resourceDefinition ) | INDENT resourceDefinitions DEDENT -> ^( PROPERTY relation resourceDefinitions ) ) | template );
 701         public final GraphParser.property_return property() throws RecognitionException {
 702                 GraphParser.property_return retval = new GraphParser.property_return();
 703                 retval.start = input.LT(1);
 704
 705                 CommonTree root_0 = null;
 706
 707                 Token INDENT19=null;
 708                 Token DEDENT21=null;
 709                 ParserRuleReturnScope relation17 =null;
 710                 ParserRuleReturnScope resourceDefinition18 =null;
 711                 ParserRuleReturnScope resourceDefinitions20 =null;
 712                 ParserRuleReturnScope template22 =null;
 713
 714                 CommonTree INDENT19_tree=null;
 715                 CommonTree DEDENT21_tree=null;
 716                 RewriteRuleTokenStream stream_INDENT=new RewriteRuleTokenStream(adaptor,"token INDENT");
 717                 RewriteRuleTokenStream stream_DEDENT=new RewriteRuleTokenStream(adaptor,"token DEDENT");
 718                 RewriteRuleSubtreeStream stream_resourceDefinition=new RewriteRuleSubtreeStream(adaptor,"rule resourceDefinition");
 719                 RewriteRuleSubtreeStream stream_resourceDefinitions=new RewriteRuleSubtreeStream(adaptor,"rule resourceDefinitions");
 720                 RewriteRuleSubtreeStream stream_relation=new RewriteRuleSubtreeStream(adaptor,"rule relation");
 721
 722                 try {
 723                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:244:5: ( relation ( resourceDefinition -> ^( PROPERTY relation resourceDefinition ) | INDENT resourceDefinitions DEDENT -> ^( PROPERTY relation resourceDefinitions ) ) | template )
 724                         int alt9=2;
 725                         int LA9_0 = input.LA(1);
 726                         if ( (LA9_0==ID||LA9_0==URI||LA9_0==66||LA9_0==68||(LA9_0 >= 70 && LA9_0 <= 76)) ) {
 727                                 alt9=1;
 728                         }
 729                         else if ( (LA9_0==77) ) {
 730                                 alt9=2;
 731                         }
 732
 733                         else {
 734                                 if (state.backtracking>0) {state.failed=true; return retval;}
 735                                 NoViableAltException nvae =
 736                                         new NoViableAltException("", 9, 0, input);
 737                                 throw nvae;
 738                         }
 739
 740                         switch (alt9) {
 741                                 case 1 :
 742                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:244:7: relation ( resourceDefinition -> ^( PROPERTY relation resourceDefinition ) | INDENT resourceDefinitions DEDENT -> ^( PROPERTY relation resourceDefinitions ) )
 743                                         {
 744                                         pushFollow(FOLLOW_relation_in_property1434);
 745                                         relation17=relation();
 746                                         state._fsp--;
 747                                         if (state.failed) return retval;
 748                                         if ( state.backtracking==0 ) stream_relation.add(relation17.getTree());
 749                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:245:7: ( resourceDefinition -> ^( PROPERTY relation resourceDefinition ) | INDENT resourceDefinitions DEDENT -> ^( PROPERTY relation resourceDefinitions ) )
 750                                         int alt8=2;
 751                                         int LA8_0 = input.LA(1);
 752                                         if ( (LA8_0==FLOAT||LA8_0==ID||LA8_0==INT||(LA8_0 >= LBRACKET && LA8_0 <= LPAREN)||LA8_0==STRING||LA8_0==URI||(LA8_0 >= 65 && LA8_0 <= 66)||(LA8_0 >= 77 && LA8_0 <= 79)) ) {
 753                                                 alt8=1;
 754                                         }
 755                                         else if ( (LA8_0==INDENT) ) {
 756                                                 alt8=2;
 757                                         }
 758
 759                                         else {
 760                                                 if (state.backtracking>0) {state.failed=true; return retval;}
 761                                                 NoViableAltException nvae =
 762                                                         new NoViableAltException("", 8, 0, input);
 763                                                 throw nvae;
 764                                         }
 765
 766                                         switch (alt8) {
 767                                                 case 1 :
 768                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:245:9: resourceDefinition
 769                                                         {
 770                                                         pushFollow(FOLLOW_resourceDefinition_in_property1444);
 771                                                         resourceDefinition18=resourceDefinition();
 772                                                         state._fsp--;
 773                                                         if (state.failed) return retval;
 774                                                         if ( state.backtracking==0 ) stream_resourceDefinition.add(resourceDefinition18.getTree());
 775                                                         // AST REWRITE
 776                                                         // elements: relation, resourceDefinition
 777                                                         // token labels:
 778                                                         // rule labels: retval
 779                                                         // token list labels:
 780                                                         // rule list labels:
 781                                                         // wildcard labels:
 782                                                         if ( state.backtracking==0 ) {
 783                                                         retval.tree = root_0;
 784                                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
 785
 786                                                         root_0 = (CommonTree)adaptor.nil();
 787                                                         // 245:28: -> ^( PROPERTY relation resourceDefinition )
 788                                                         {
 789                                                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:245:31: ^( PROPERTY relation resourceDefinition )
 790                                                                 {
 791                                                                 CommonTree root_1 = (CommonTree)adaptor.nil();
 792                                                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(PROPERTY, "PROPERTY"), root_1);
 793                                                                 adaptor.addChild(root_1, stream_relation.nextTree());
 794                                                                 adaptor.addChild(root_1, stream_resourceDefinition.nextTree());
 795                                                                 adaptor.addChild(root_0, root_1);
 796                                                                 }
 797
 798                                                         }
 799
 800
 801                                                         retval.tree = root_0;
 802                                                         }
 803
 804                                                         }
 805                                                         break;
 806                                                 case 2 :
 807                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:246:9: INDENT resourceDefinitions DEDENT
 808                                                         {
 809                                                         INDENT19=(Token)match(input,INDENT,FOLLOW_INDENT_in_property1464); if (state.failed) return retval;
 810                                                         if ( state.backtracking==0 ) stream_INDENT.add(INDENT19);
 811
 812                                                         pushFollow(FOLLOW_resourceDefinitions_in_property1466);
 813                                                         resourceDefinitions20=resourceDefinitions();
 814                                                         state._fsp--;
 815                                                         if (state.failed) return retval;
 816                                                         if ( state.backtracking==0 ) stream_resourceDefinitions.add(resourceDefinitions20.getTree());
 817                                                         DEDENT21=(Token)match(input,DEDENT,FOLLOW_DEDENT_in_property1468); if (state.failed) return retval;
 818                                                         if ( state.backtracking==0 ) stream_DEDENT.add(DEDENT21);
 819
 820                                                         // AST REWRITE
 821                                                         // elements: relation, resourceDefinitions
 822                                                         // token labels:
 823                                                         // rule labels: retval
 824                                                         // token list labels:
 825                                                         // rule list labels:
 826                                                         // wildcard labels:
 827                                                         if ( state.backtracking==0 ) {
 828                                                         retval.tree = root_0;
 829                                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
 830
 831                                                         root_0 = (CommonTree)adaptor.nil();
 832                                                         // 246:43: -> ^( PROPERTY relation resourceDefinitions )
 833                                                         {
 834                                                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:246:46: ^( PROPERTY relation resourceDefinitions )
 835                                                                 {
 836                                                                 CommonTree root_1 = (CommonTree)adaptor.nil();
 837                                                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(PROPERTY, "PROPERTY"), root_1);
 838                                                                 adaptor.addChild(root_1, stream_relation.nextTree());
 839                                                                 adaptor.addChild(root_1, stream_resourceDefinitions.nextTree());
 840                                                                 adaptor.addChild(root_0, root_1);
 841                                                                 }
 842
 843                                                         }
 844
 845
 846                                                         retval.tree = root_0;
 847                                                         }
 848
 849                                                         }
 850                                                         break;
 851
 852                                         }
 853
 854                                         }
 855                                         break;
 856                                 case 2 :
 857                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:248:7: template
 858                                         {
 859                                         root_0 = (CommonTree)adaptor.nil();
 860
 861
 862                                         pushFollow(FOLLOW_template_in_property1494);
 863                                         template22=template();
 864                                         state._fsp--;
 865                                         if (state.failed) return retval;
 866                                         if ( state.backtracking==0 ) adaptor.addChild(root_0, template22.getTree());
 867
 868                                         }
 869                                         break;
 870
 871                         }
 872                         retval.stop = input.LT(-1);
 873
 874                         if ( state.backtracking==0 ) {
 875                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 876                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 877                         }
 878                 }
 879                 catch (RecognitionException re) {
 880                         reportError(re);
 881                         recover(input,re);
 882                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 883                 }
 884                 finally {
 885                         // do for sure before leaving
 886                 }
 887                 return retval;
 888         }
 889         // $ANTLR end "property"
 890
 891
 892         public static class template_return extends ParserRuleReturnScope {
 893                 CommonTree tree;
 894                 @Override
 895                 public CommonTree getTree() { return tree; }
 896         };
 897
 898
 899         // $ANTLR start "template"
 900         // 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 )? ) ) ;
 901         public final GraphParser.template_return template() throws RecognitionException {
 902                 GraphParser.template_return retval = new GraphParser.template_return();
 903                 retval.start = input.LT(1);
 904
 905                 CommonTree root_0 = null;
 906
 907                 Token char_literal23=null;
 908                 Token ID24=null;
 909                 Token INDENT26=null;
 910                 Token DEDENT28=null;
 911                 Token INDENT30=null;
 912                 Token DEDENT32=null;
 913                 ParserRuleReturnScope resource25 =null;
 914                 ParserRuleReturnScope resourceDefinitions27 =null;
 915                 ParserRuleReturnScope resource29 =null;
 916                 ParserRuleReturnScope resourceDefinitions31 =null;
 917
 918                 CommonTree char_literal23_tree=null;
 919                 CommonTree ID24_tree=null;
 920                 CommonTree INDENT26_tree=null;
 921                 CommonTree DEDENT28_tree=null;
 922                 CommonTree INDENT30_tree=null;
 923                 CommonTree DEDENT32_tree=null;
 924                 RewriteRuleTokenStream stream_INDENT=new RewriteRuleTokenStream(adaptor,"token INDENT");
 925                 RewriteRuleTokenStream stream_77=new RewriteRuleTokenStream(adaptor,"token 77");
 926                 RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
 927                 RewriteRuleTokenStream stream_DEDENT=new RewriteRuleTokenStream(adaptor,"token DEDENT");
 928                 RewriteRuleSubtreeStream stream_resource=new RewriteRuleSubtreeStream(adaptor,"rule resource");
 929                 RewriteRuleSubtreeStream stream_resourceDefinitions=new RewriteRuleSubtreeStream(adaptor,"rule resourceDefinitions");
 930
 931                 try {
 932                         // 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 )? ) ) )
 933                         // 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 )? ) )
 934                         {
 935                         char_literal23=(Token)match(input,77,FOLLOW_77_in_template1515); if (state.failed) return retval;
 936                         if ( state.backtracking==0 ) stream_77.add(char_literal23);
 937
 938                         // 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 )? ) )
 939                         int alt13=2;
 940                         int LA13_0 = input.LA(1);
 941                         if ( (LA13_0==ID) ) {
 942                                 int LA13_1 = input.LA(2);
 943                                 if ( ((input.LT(1).getText().equals("template"))) ) {
 944                                         alt13=1;
 945                                 }
 946                                 else if ( (true) ) {
 947                                         alt13=2;
 948                                 }
 949
 950                         }
 951                         else if ( (LA13_0==FLOAT||LA13_0==INT||(LA13_0 >= LBRACKET && LA13_0 <= LPAREN)||LA13_0==STRING||LA13_0==URI||(LA13_0 >= 65 && LA13_0 <= 66)||(LA13_0 >= 78 && LA13_0 <= 79)) ) {
 952                                 alt13=2;
 953                         }
 954
 955                         else {
 956                                 if (state.backtracking>0) {state.failed=true; return retval;}
 957                                 NoViableAltException nvae =
 958                                         new NoViableAltException("", 13, 0, input);
 959                                 throw nvae;
 960                         }
 961
 962                         switch (alt13) {
 963                                 case 1 :
 964                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:253:7: {...}? => ID ( resource )+ INDENT resourceDefinitions DEDENT
 965                                         {
 966                                         if ( !((input.LT(1).getText().equals("template"))) ) {
 967                                                 if (state.backtracking>0) {state.failed=true; return retval;}
 968                                                 throw new FailedPredicateException(input, "template", "input.LT(1).getText().equals(\"template\")");
 969                                         }
 970                                         ID24=(Token)match(input,ID,FOLLOW_ID_in_template1533); if (state.failed) return retval;
 971                                         if ( state.backtracking==0 ) stream_ID.add(ID24);
 972
 973                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:254:10: ( resource )+
 974                                         int cnt10=0;
 975                                         loop10:
 976                                         while (true) {
 977                                                 int alt10=2;
 978                                                 int LA10_0 = input.LA(1);
 979                                                 if ( (LA10_0==FLOAT||LA10_0==ID||LA10_0==INT||(LA10_0 >= LBRACKET && LA10_0 <= LPAREN)||LA10_0==STRING||LA10_0==URI||(LA10_0 >= 65 && LA10_0 <= 66)||(LA10_0 >= 78 && LA10_0 <= 79)) ) {
 980                                                         alt10=1;
 981                                                 }
 982
 983                                                 switch (alt10) {
 984                                                 case 1 :
 985                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:254:10: resource
 986                                                         {
 987                                                         pushFollow(FOLLOW_resource_in_template1535);
 988                                                         resource25=resource();
 989                                                         state._fsp--;
 990                                                         if (state.failed) return retval;
 991                                                         if ( state.backtracking==0 ) stream_resource.add(resource25.getTree());
 992                                                         }
 993                                                         break;
 994
 995                                                 default :
 996                                                         if ( cnt10 >= 1 ) break loop10;
 997                                                         if (state.backtracking>0) {state.failed=true; return retval;}
 998                                                         EarlyExitException eee = new EarlyExitException(10, input);
 999                                                         throw eee;
1000                                                 }
1001                                                 cnt10++;
1002                                         }
1003
1004                                         INDENT26=(Token)match(input,INDENT,FOLLOW_INDENT_in_template1545); if (state.failed) return retval;
1005                                         if ( state.backtracking==0 ) stream_INDENT.add(INDENT26);
1006
1007                                         pushFollow(FOLLOW_resourceDefinitions_in_template1547);
1008                                         resourceDefinitions27=resourceDefinitions();
1009                                         state._fsp--;
1010                                         if (state.failed) return retval;
1011                                         if ( state.backtracking==0 ) stream_resourceDefinitions.add(resourceDefinitions27.getTree());
1012                                         DEDENT28=(Token)match(input,DEDENT,FOLLOW_DEDENT_in_template1549); if (state.failed) return retval;
1013                                         if ( state.backtracking==0 ) stream_DEDENT.add(DEDENT28);
1014
1015                                         // AST REWRITE
1016                                         // elements: resourceDefinitions, resource
1017                                         // token labels:
1018                                         // rule labels: retval
1019                                         // token list labels:
1020                                         // rule list labels:
1021                                         // wildcard labels:
1022                                         if ( state.backtracking==0 ) {
1023                                         retval.tree = root_0;
1024                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
1025
1026                                         root_0 = (CommonTree)adaptor.nil();
1027                                         // 256:7: -> ^( TEMPLATE_DEFINITION ( resource )+ resourceDefinitions )
1028                                         {
1029                                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:256:10: ^( TEMPLATE_DEFINITION ( resource )+ resourceDefinitions )
1030                                                 {
1031                                                 CommonTree root_1 = (CommonTree)adaptor.nil();
1032                                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TEMPLATE_DEFINITION, "TEMPLATE_DEFINITION"), root_1);
1033                                                 if ( !(stream_resource.hasNext()) ) {
1034                                                         throw new RewriteEarlyExitException();
1035                                                 }
1036                                                 while ( stream_resource.hasNext() ) {
1037                                                         adaptor.addChild(root_1, stream_resource.nextTree());
1038                                                 }
1039                                                 stream_resource.reset();
1040
1041                                                 adaptor.addChild(root_1, stream_resourceDefinitions.nextTree());
1042                                                 adaptor.addChild(root_0, root_1);
1043                                                 }
1044
1045                                         }
1046
1047
1048                                         retval.tree = root_0;
1049                                         }
1050
1051                                         }
1052                                         break;
1053                                 case 2 :
1054                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:257:7: ( resource )+ ( INDENT resourceDefinitions DEDENT )?
1055                                         {
1056                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:257:7: ( resource )+
1057                                         int cnt11=0;
1058                                         loop11:
1059                                         while (true) {
1060                                                 int alt11=2;
1061                                                 int LA11_0 = input.LA(1);
1062                                                 if ( (LA11_0==FLOAT||LA11_0==ID||LA11_0==INT||(LA11_0 >= LBRACKET && LA11_0 <= LPAREN)||LA11_0==STRING||LA11_0==URI||(LA11_0 >= 65 && LA11_0 <= 66)||(LA11_0 >= 78 && LA11_0 <= 79)) ) {
1063                                                         alt11=1;
1064                                                 }
1065
1066                                                 switch (alt11) {
1067                                                 case 1 :
1068                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:257:7: resource
1069                                                         {
1070                                                         pushFollow(FOLLOW_resource_in_template1574);
1071                                                         resource29=resource();
1072                                                         state._fsp--;
1073                                                         if (state.failed) return retval;
1074                                                         if ( state.backtracking==0 ) stream_resource.add(resource29.getTree());
1075                                                         }
1076                                                         break;
1077
1078                                                 default :
1079                                                         if ( cnt11 >= 1 ) break loop11;
1080                                                         if (state.backtracking>0) {state.failed=true; return retval;}
1081                                                         EarlyExitException eee = new EarlyExitException(11, input);
1082                                                         throw eee;
1083                                                 }
1084                                                 cnt11++;
1085                                         }
1086
1087                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:258:7: ( INDENT resourceDefinitions DEDENT )?
1088                                         int alt12=2;
1089                                         int LA12_0 = input.LA(1);
1090                                         if ( (LA12_0==INDENT) ) {
1091                                                 alt12=1;
1092                                         }
1093                                         switch (alt12) {
1094                                                 case 1 :
1095                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:258:8: INDENT resourceDefinitions DEDENT
1096                                                         {
1097                                                         INDENT30=(Token)match(input,INDENT,FOLLOW_INDENT_in_template1585); if (state.failed) return retval;
1098                                                         if ( state.backtracking==0 ) stream_INDENT.add(INDENT30);
1099
1100                                                         pushFollow(FOLLOW_resourceDefinitions_in_template1587);
1101                                                         resourceDefinitions31=resourceDefinitions();
1102                                                         state._fsp--;
1103                                                         if (state.failed) return retval;
1104                                                         if ( state.backtracking==0 ) stream_resourceDefinitions.add(resourceDefinitions31.getTree());
1105                                                         DEDENT32=(Token)match(input,DEDENT,FOLLOW_DEDENT_in_template1589); if (state.failed) return retval;
1106                                                         if ( state.backtracking==0 ) stream_DEDENT.add(DEDENT32);
1107
1108                                                         }
1109                                                         break;
1110
1111                                         }
1112
1113                                         // AST REWRITE
1114                                         // elements: resource, resourceDefinitions
1115                                         // token labels:
1116                                         // rule labels: retval
1117                                         // token list labels:
1118                                         // rule list labels:
1119                                         // wildcard labels:
1120                                         if ( state.backtracking==0 ) {
1121                                         retval.tree = root_0;
1122                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
1123
1124                                         root_0 = (CommonTree)adaptor.nil();
1125                                         // 259:7: -> ^( TEMPLATE_INSTANCE ( resource )+ ( resourceDefinitions )? )
1126                                         {
1127                                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:259:10: ^( TEMPLATE_INSTANCE ( resource )+ ( resourceDefinitions )? )
1128                                                 {
1129                                                 CommonTree root_1 = (CommonTree)adaptor.nil();
1130                                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TEMPLATE_INSTANCE, "TEMPLATE_INSTANCE"), root_1);
1131                                                 if ( !(stream_resource.hasNext()) ) {
1132                                                         throw new RewriteEarlyExitException();
1133                                                 }
1134                                                 while ( stream_resource.hasNext() ) {
1135                                                         adaptor.addChild(root_1, stream_resource.nextTree());
1136                                                 }
1137                                                 stream_resource.reset();
1138
1139                                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:259:40: ( resourceDefinitions )?
1140                                                 if ( stream_resourceDefinitions.hasNext() ) {
1141                                                         adaptor.addChild(root_1, stream_resourceDefinitions.nextTree());
1142                                                 }
1143                                                 stream_resourceDefinitions.reset();
1144
1145                                                 adaptor.addChild(root_0, root_1);
1146                                                 }
1147
1148                                         }
1149
1150
1151                                         retval.tree = root_0;
1152                                         }
1153
1154                                         }
1155                                         break;
1156
1157                         }
1158
1159                         }
1160
1161                         retval.stop = input.LT(-1);
1162
1163                         if ( state.backtracking==0 ) {
1164                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1165                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1166                         }
1167                 }
1168                 catch (RecognitionException re) {
1169                         reportError(re);
1170                         recover(input,re);
1171                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
1172                 }
1173                 finally {
1174                         // do for sure before leaving
1175                 }
1176                 return retval;
1177         }
1178         // $ANTLR end "template"
1179
1180
1181         public static class relation_return extends ParserRuleReturnScope {
1182                 CommonTree tree;
1183                 @Override
1184                 public CommonTree getTree() { return tree; }
1185         };
1186
1187
1188         // $ANTLR start "relation"
1189         // 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 ) );
1190         public final GraphParser.relation_return relation() throws RecognitionException {
1191                 GraphParser.relation_return retval = new GraphParser.relation_return();
1192                 retval.start = input.LT(1);
1193
1194                 CommonTree root_0 = null;
1195
1196                 Token ID33=null;
1197                 Token char_literal34=null;
1198                 Token ID35=null;
1199                 Token URI36=null;
1200                 Token string_literal37=null;
1201                 Token string_literal38=null;
1202                 Token string_literal39=null;
1203                 Token string_literal40=null;
1204                 Token string_literal41=null;
1205                 Token string_literal42=null;
1206                 Token char_literal43=null;
1207                 Token char_literal44=null;
1208                 Token char_literal45=null;
1209                 Token ID46=null;
1210
1211                 CommonTree ID33_tree=null;
1212                 CommonTree char_literal34_tree=null;
1213                 CommonTree ID35_tree=null;
1214                 CommonTree URI36_tree=null;
1215                 CommonTree string_literal37_tree=null;
1216                 CommonTree string_literal38_tree=null;
1217                 CommonTree string_literal39_tree=null;
1218                 CommonTree string_literal40_tree=null;
1219                 CommonTree string_literal41_tree=null;
1220                 CommonTree string_literal42_tree=null;
1221                 CommonTree char_literal43_tree=null;
1222                 CommonTree char_literal44_tree=null;
1223                 CommonTree char_literal45_tree=null;
1224                 CommonTree ID46_tree=null;
1225                 RewriteRuleTokenStream stream_66=new RewriteRuleTokenStream(adaptor,"token 66");
1226                 RewriteRuleTokenStream stream_68=new RewriteRuleTokenStream(adaptor,"token 68");
1227                 RewriteRuleTokenStream stream_69=new RewriteRuleTokenStream(adaptor,"token 69");
1228                 RewriteRuleTokenStream stream_70=new RewriteRuleTokenStream(adaptor,"token 70");
1229                 RewriteRuleTokenStream stream_71=new RewriteRuleTokenStream(adaptor,"token 71");
1230                 RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
1231                 RewriteRuleTokenStream stream_72=new RewriteRuleTokenStream(adaptor,"token 72");
1232                 RewriteRuleTokenStream stream_73=new RewriteRuleTokenStream(adaptor,"token 73");
1233                 RewriteRuleTokenStream stream_74=new RewriteRuleTokenStream(adaptor,"token 74");
1234                 RewriteRuleTokenStream stream_75=new RewriteRuleTokenStream(adaptor,"token 75");
1235                 RewriteRuleTokenStream stream_76=new RewriteRuleTokenStream(adaptor,"token 76");
1236
1237                 try {
1238                         // 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 ) )
1239                         int alt15=11;
1240                         switch ( input.LA(1) ) {
1241                         case ID:
1242                                 {
1243                                 alt15=1;
1244                                 }
1245                                 break;
1246                         case URI:
1247                                 {
1248                                 alt15=2;
1249                                 }
1250                                 break;
1251                         case 73:
1252                                 {
1253                                 alt15=3;
1254                                 }
1255                                 break;
1256                         case 72:
1257                                 {
1258                                 alt15=4;
1259                                 }
1260                                 break;
1261                         case 71:
1262                                 {
1263                                 alt15=5;
1264                                 }
1265                                 break;
1266                         case 68:
1267                                 {
1268                                 alt15=6;
1269                                 }
1270                                 break;
1271                         case 75:
1272                                 {
1273                                 alt15=7;
1274                                 }
1275                                 break;
1276                         case 76:
1277                                 {
1278                                 alt15=8;
1279                                 }
1280                                 break;
1281                         case 70:
1282                                 {
1283                                 alt15=9;
1284                                 }
1285                                 break;
1286                         case 74:
1287                                 {
1288                                 alt15=10;
1289                                 }
1290                                 break;
1291                         case 66:
1292                                 {
1293                                 alt15=11;
1294                                 }
1295                                 break;
1296                         default:
1297                                 if (state.backtracking>0) {state.failed=true; return retval;}
1298                                 NoViableAltException nvae =
1299                                         new NoViableAltException("", 15, 0, input);
1300                                 throw nvae;
1301                         }
1302                         switch (alt15) {
1303                                 case 1 :
1304                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:268:7: ( ID -> ID ) ( '.' ID -> ^( REF $relation ID ) )*
1305                                         {
1306                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:268:7: ( ID -> ID )
1307                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:268:9: ID
1308                                         {
1309                                         ID33=(Token)match(input,ID,FOLLOW_ID_in_relation1643); if (state.failed) return retval;
1310                                         if ( state.backtracking==0 ) stream_ID.add(ID33);
1311
1312                                         // AST REWRITE
1313                                         // elements: ID
1314                                         // token labels:
1315                                         // rule labels: retval
1316                                         // token list labels:
1317                                         // rule list labels:
1318                                         // wildcard labels:
1319                                         if ( state.backtracking==0 ) {
1320                                         retval.tree = root_0;
1321                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
1322
1323                                         root_0 = (CommonTree)adaptor.nil();
1324                                         // 268:12: -> ID
1325                                         {
1326                                                 adaptor.addChild(root_0, stream_ID.nextNode());
1327                                         }
1328
1329
1330                                         retval.tree = root_0;
1331                                         }
1332
1333                                         }
1334
1335                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:269:7: ( '.' ID -> ^( REF $relation ID ) )*
1336                                         loop14:
1337                                         while (true) {
1338                                                 int alt14=2;
1339                                                 int LA14_0 = input.LA(1);
1340                                                 if ( (LA14_0==69) ) {
1341                                                         alt14=1;
1342                                                 }
1343
1344                                                 switch (alt14) {
1345                                                 case 1 :
1346                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:269:8: '.' ID
1347                                                         {
1348                                                         char_literal34=(Token)match(input,69,FOLLOW_69_in_relation1658); if (state.failed) return retval;
1349                                                         if ( state.backtracking==0 ) stream_69.add(char_literal34);
1350
1351                                                         ID35=(Token)match(input,ID,FOLLOW_ID_in_relation1660); if (state.failed) return retval;
1352                                                         if ( state.backtracking==0 ) stream_ID.add(ID35);
1353
1354                                                         // AST REWRITE
1355                                                         // elements: relation, ID
1356                                                         // token labels:
1357                                                         // rule labels: retval
1358                                                         // token list labels:
1359                                                         // rule list labels:
1360                                                         // wildcard labels:
1361                                                         if ( state.backtracking==0 ) {
1362                                                         retval.tree = root_0;
1363                                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
1364
1365                                                         root_0 = (CommonTree)adaptor.nil();
1366                                                         // 269:15: -> ^( REF $relation ID )
1367                                                         {
1368                                                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:269:18: ^( REF $relation ID )
1369                                                                 {
1370                                                                 CommonTree root_1 = (CommonTree)adaptor.nil();
1371                                                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(REF, "REF"), root_1);
1372                                                                 adaptor.addChild(root_1, stream_retval.nextTree());
1373                                                                 adaptor.addChild(root_1, stream_ID.nextNode());
1374                                                                 adaptor.addChild(root_0, root_1);
1375                                                                 }
1376
1377                                                         }
1378
1379
1380                                                         retval.tree = root_0;
1381                                                         }
1382
1383                                                         }
1384                                                         break;
1385
1386                                                 default :
1387                                                         break loop14;
1388                                                 }
1389                                         }
1390
1391                                         }
1392                                         break;
1393                                 case 2 :
1394                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:270:7: URI
1395                                         {
1396                                         root_0 = (CommonTree)adaptor.nil();
1397
1398
1399                                         URI36=(Token)match(input,URI,FOLLOW_URI_in_relation1681); if (state.failed) return retval;
1400                                         if ( state.backtracking==0 ) {
1401                                         URI36_tree = (CommonTree)adaptor.create(URI36);
1402                                         adaptor.addChild(root_0, URI36_tree);
1403                                         }
1404
1405                                         }
1406                                         break;
1407                                 case 3 :
1408                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:271:7: '<T'
1409                                         {
1410                                         string_literal37=(Token)match(input,73,FOLLOW_73_in_relation1689); if (state.failed) return retval;
1411                                         if ( state.backtracking==0 ) stream_73.add(string_literal37);
1412
1413                                         // AST REWRITE
1414                                         // elements:
1415                                         // token labels:
1416                                         // rule labels: retval
1417                                         // token list labels:
1418                                         // rule list labels:
1419                                         // wildcard labels:
1420                                         if ( state.backtracking==0 ) {
1421                                         retval.tree = root_0;
1422                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
1423
1424                                         root_0 = (CommonTree)adaptor.nil();
1425                                         // 271:12: -> INHERITS
1426                                         {
1427                                                 adaptor.addChild(root_0, (CommonTree)adaptor.create(INHERITS, "INHERITS"));
1428                                         }
1429
1430
1431                                         retval.tree = root_0;
1432                                         }
1433
1434                                         }
1435                                         break;
1436                                 case 4 :
1437                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:272:7: '<R'
1438                                         {
1439                                         string_literal38=(Token)match(input,72,FOLLOW_72_in_relation1701); if (state.failed) return retval;
1440                                         if ( state.backtracking==0 ) stream_72.add(string_literal38);
1441
1442                                         // AST REWRITE
1443                                         // elements:
1444                                         // token labels:
1445                                         // rule labels: retval
1446                                         // token list labels:
1447                                         // rule list labels:
1448                                         // wildcard labels:
1449                                         if ( state.backtracking==0 ) {
1450                                         retval.tree = root_0;
1451                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
1452
1453                                         root_0 = (CommonTree)adaptor.nil();
1454                                         // 272:12: -> SUBRELATION_OF
1455                                         {
1456                                                 adaptor.addChild(root_0, (CommonTree)adaptor.create(SUBRELATION_OF, "SUBRELATION_OF"));
1457                                         }
1458
1459
1460                                         retval.tree = root_0;
1461                                         }
1462
1463                                         }
1464                                         break;
1465                                 case 5 :
1466                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:273:7: '<--'
1467                                         {
1468                                         string_literal39=(Token)match(input,71,FOLLOW_71_in_relation1713); if (state.failed) return retval;
1469                                         if ( state.backtracking==0 ) stream_71.add(string_literal39);
1470
1471                                         // AST REWRITE
1472                                         // elements:
1473                                         // token labels:
1474                                         // rule labels: retval
1475                                         // token list labels:
1476                                         // rule list labels:
1477                                         // wildcard labels:
1478                                         if ( state.backtracking==0 ) {
1479                                         retval.tree = root_0;
1480                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
1481
1482                                         root_0 = (CommonTree)adaptor.nil();
1483                                         // 273:13: -> HAS_DOMAIN
1484                                         {
1485                                                 adaptor.addChild(root_0, (CommonTree)adaptor.create(HAS_DOMAIN, "HAS_DOMAIN"));
1486                                         }
1487
1488
1489                                         retval.tree = root_0;
1490                                         }
1491
1492                                         }
1493                                         break;
1494                                 case 6 :
1495                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:274:7: '-->'
1496                                         {
1497                                         string_literal40=(Token)match(input,68,FOLLOW_68_in_relation1725); if (state.failed) return retval;
1498                                         if ( state.backtracking==0 ) stream_68.add(string_literal40);
1499
1500                                         // AST REWRITE
1501                                         // elements:
1502                                         // token labels:
1503                                         // rule labels: retval
1504                                         // token list labels:
1505                                         // rule list labels:
1506                                         // wildcard labels:
1507                                         if ( state.backtracking==0 ) {
1508                                         retval.tree = root_0;
1509                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
1510
1511                                         root_0 = (CommonTree)adaptor.nil();
1512                                         // 274:13: -> HAS_RANGE
1513                                         {
1514                                                 adaptor.addChild(root_0, (CommonTree)adaptor.create(HAS_RANGE, "HAS_RANGE"));
1515                                         }
1516
1517
1518                                         retval.tree = root_0;
1519                                         }
1520
1521                                         }
1522                                         break;
1523                                 case 7 :
1524                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:275:7: '==>'
1525                                         {
1526                                         string_literal41=(Token)match(input,75,FOLLOW_75_in_relation1737); if (state.failed) return retval;
1527                                         if ( state.backtracking==0 ) stream_75.add(string_literal41);
1528
1529                                         // AST REWRITE
1530                                         // elements:
1531                                         // token labels:
1532                                         // rule labels: retval
1533                                         // token list labels:
1534                                         // rule list labels:
1535                                         // wildcard labels:
1536                                         if ( state.backtracking==0 ) {
1537                                         retval.tree = root_0;
1538                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
1539
1540                                         root_0 = (CommonTree)adaptor.nil();
1541                                         // 275:13: -> REQUIRES_VALUE_TYPE
1542                                         {
1543                                                 adaptor.addChild(root_0, (CommonTree)adaptor.create(REQUIRES_VALUE_TYPE, "REQUIRES_VALUE_TYPE"));
1544                                         }
1545
1546
1547                                         retval.tree = root_0;
1548                                         }
1549
1550                                         }
1551                                         break;
1552                                 case 8 :
1553                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:276:7: '>--'
1554                                         {
1555                                         string_literal42=(Token)match(input,76,FOLLOW_76_in_relation1749); if (state.failed) return retval;
1556                                         if ( state.backtracking==0 ) stream_76.add(string_literal42);
1557
1558                                         // AST REWRITE
1559                                         // elements:
1560                                         // token labels:
1561                                         // rule labels: retval
1562                                         // token list labels:
1563                                         // rule list labels:
1564                                         // wildcard labels:
1565                                         if ( state.backtracking==0 ) {
1566                                         retval.tree = root_0;
1567                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
1568
1569                                         root_0 = (CommonTree)adaptor.nil();
1570                                         // 276:13: -> DOMAIN_OF
1571                                         {
1572                                                 adaptor.addChild(root_0, (CommonTree)adaptor.create(DOMAIN_OF, "DOMAIN_OF"));
1573                                         }
1574
1575
1576                                         retval.tree = root_0;
1577                                         }
1578
1579                                         }
1580                                         break;
1581                                 case 9 :
1582                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:277:7: ':'
1583                                         {
1584                                         char_literal43=(Token)match(input,70,FOLLOW_70_in_relation1765); if (state.failed) return retval;
1585                                         if ( state.backtracking==0 ) stream_70.add(char_literal43);
1586
1587                                         // AST REWRITE
1588                                         // elements:
1589                                         // token labels:
1590                                         // rule labels: retval
1591                                         // token list labels:
1592                                         // rule list labels:
1593                                         // wildcard labels:
1594                                         if ( state.backtracking==0 ) {
1595                                         retval.tree = root_0;
1596                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
1597
1598                                         root_0 = (CommonTree)adaptor.nil();
1599                                         // 277:11: -> INSTANCE_OF
1600                                         {
1601                                                 adaptor.addChild(root_0, (CommonTree)adaptor.create(INSTANCE_OF, "INSTANCE_OF"));
1602                                         }
1603
1604
1605                                         retval.tree = root_0;
1606                                         }
1607
1608                                         }
1609                                         break;
1610                                 case 10 :
1611                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:278:7: '='
1612                                         {
1613                                         char_literal44=(Token)match(input,74,FOLLOW_74_in_relation1777); if (state.failed) return retval;
1614                                         if ( state.backtracking==0 ) stream_74.add(char_literal44);
1615
1616                                         // AST REWRITE
1617                                         // elements:
1618                                         // token labels:
1619                                         // rule labels: retval
1620                                         // token list labels:
1621                                         // rule list labels:
1622                                         // wildcard labels:
1623                                         if ( state.backtracking==0 ) {
1624                                         retval.tree = root_0;
1625                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
1626
1627                                         root_0 = (CommonTree)adaptor.nil();
1628                                         // 278:11: -> EQUALS
1629                                         {
1630                                                 adaptor.addChild(root_0, (CommonTree)adaptor.create(EQUALS, "EQUALS"));
1631                                         }
1632
1633
1634                                         retval.tree = root_0;
1635                                         }
1636
1637                                         }
1638                                         break;
1639                                 case 11 :
1640                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:279:7: '%' ID
1641                                         {
1642                                         char_literal45=(Token)match(input,66,FOLLOW_66_in_relation1789); if (state.failed) return retval;
1643                                         if ( state.backtracking==0 ) stream_66.add(char_literal45);
1644
1645                                         ID46=(Token)match(input,ID,FOLLOW_ID_in_relation1791); if (state.failed) return retval;
1646                                         if ( state.backtracking==0 ) stream_ID.add(ID46);
1647
1648                                         // AST REWRITE
1649                                         // elements: ID
1650                                         // token labels:
1651                                         // rule labels: retval
1652                                         // token list labels:
1653                                         // rule list labels:
1654                                         // wildcard labels:
1655                                         if ( state.backtracking==0 ) {
1656                                         retval.tree = root_0;
1657                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
1658
1659                                         root_0 = (CommonTree)adaptor.nil();
1660                                         // 279:14: -> ^( VARIABLE ID )
1661                                         {
1662                                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:279:17: ^( VARIABLE ID )
1663                                                 {
1664                                                 CommonTree root_1 = (CommonTree)adaptor.nil();
1665                                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(VARIABLE, "VARIABLE"), root_1);
1666                                                 adaptor.addChild(root_1, stream_ID.nextNode());
1667                                                 adaptor.addChild(root_0, root_1);
1668                                                 }
1669
1670                                         }
1671
1672
1673                                         retval.tree = root_0;
1674                                         }
1675
1676                                         }
1677                                         break;
1678
1679                         }
1680                         retval.stop = input.LT(-1);
1681
1682                         if ( state.backtracking==0 ) {
1683                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1684                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1685                         }
1686                 }
1687                 catch (RecognitionException re) {
1688                         reportError(re);
1689                         recover(input,re);
1690                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
1691                 }
1692                 finally {
1693                         // do for sure before leaving
1694                 }
1695                 return retval;
1696         }
1697         // $ANTLR end "relation"
1698
1699
1700         public static class resource_return extends ParserRuleReturnScope {
1701                 CommonTree tree;
1702                 @Override
1703                 public CommonTree getTree() { return tree; }
1704         };
1705
1706
1707         // $ANTLR start "resource"
1708         // 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 ) );
1709         public final GraphParser.resource_return resource() throws RecognitionException {
1710                 GraphParser.resource_return retval = new GraphParser.resource_return();
1711                 retval.start = input.LT(1);
1712
1713                 CommonTree root_0 = null;
1714
1715                 Token ID47=null;
1716                 Token ID48=null;
1717                 Token char_literal49=null;
1718                 Token ID50=null;
1719                 Token STRING51=null;
1720                 Token URI52=null;
1721                 Token char_literal54=null;
1722                 Token char_literal56=null;
1723                 Token ID57=null;
1724                 ParserRuleReturnScope simpleValue53 =null;
1725                 ParserRuleReturnScope basicType55 =null;
1726
1727                 CommonTree ID47_tree=null;
1728                 CommonTree ID48_tree=null;
1729                 CommonTree char_literal49_tree=null;
1730                 CommonTree ID50_tree=null;
1731                 CommonTree STRING51_tree=null;
1732                 CommonTree URI52_tree=null;
1733                 CommonTree char_literal54_tree=null;
1734                 CommonTree char_literal56_tree=null;
1735                 CommonTree ID57_tree=null;
1736                 RewriteRuleTokenStream stream_66=new RewriteRuleTokenStream(adaptor,"token 66");
1737                 RewriteRuleTokenStream stream_69=new RewriteRuleTokenStream(adaptor,"token 69");
1738                 RewriteRuleTokenStream stream_STRING=new RewriteRuleTokenStream(adaptor,"token STRING");
1739                 RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
1740                 RewriteRuleTokenStream stream_65=new RewriteRuleTokenStream(adaptor,"token 65");
1741                 RewriteRuleSubtreeStream stream_basicType=new RewriteRuleSubtreeStream(adaptor,"rule basicType");
1742                 RewriteRuleSubtreeStream stream_simpleValue=new RewriteRuleSubtreeStream(adaptor,"rule simpleValue");
1743
1744                 try {
1745                         // 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 ) )
1746                         int alt19=5;
1747                         switch ( input.LA(1) ) {
1748                         case ID:
1749                                 {
1750                                 alt19=1;
1751                                 }
1752                                 break;
1753                         case URI:
1754                                 {
1755                                 alt19=2;
1756                                 }
1757                                 break;
1758                         case FLOAT:
1759                         case INT:
1760                         case LBRACKET:
1761                         case LCURLY:
1762                         case LPAREN:
1763                         case STRING:
1764                         case 78:
1765                         case 79:
1766                                 {
1767                                 alt19=3;
1768                                 }
1769                                 break;
1770                         case 65:
1771                                 {
1772                                 alt19=4;
1773                                 }
1774                                 break;
1775                         case 66:
1776                                 {
1777                                 alt19=5;
1778                                 }
1779                                 break;
1780                         default:
1781                                 if (state.backtracking>0) {state.failed=true; return retval;}
1782                                 NoViableAltException nvae =
1783                                         new NoViableAltException("", 19, 0, input);
1784                                 throw nvae;
1785                         }
1786                         switch (alt19) {
1787                                 case 1 :
1788                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:283:7: ({...}? => ID -> ^( BLANK ID ) | ID -> ID ) ( '.' ( ID -> ^( REF $resource ID ) | STRING -> ^( REF $resource STRING ) ) )*
1789                                         {
1790                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:283:7: ({...}? => ID -> ^( BLANK ID ) | ID -> ID )
1791                                         int alt16=2;
1792                                         int LA16_0 = input.LA(1);
1793                                         if ( (LA16_0==ID) ) {
1794                                                 int LA16_1 = input.LA(2);
1795                                                 if ( ((input.LT(1).getText().equals("_"))) ) {
1796                                                         alt16=1;
1797                                                 }
1798                                                 else if ( (true) ) {
1799                                                         alt16=2;
1800                                                 }
1801
1802                                         }
1803
1804                                         else {
1805                                                 if (state.backtracking>0) {state.failed=true; return retval;}
1806                                                 NoViableAltException nvae =
1807                                                         new NoViableAltException("", 16, 0, input);
1808                                                 throw nvae;
1809                                         }
1810
1811                                         switch (alt16) {
1812                                                 case 1 :
1813                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:283:9: {...}? => ID
1814                                                         {
1815                                                         if ( !((input.LT(1).getText().equals("_"))) ) {
1816                                                                 if (state.backtracking>0) {state.failed=true; return retval;}
1817                                                                 throw new FailedPredicateException(input, "resource", "input.LT(1).getText().equals(\"_\")");
1818                                                         }
1819                                                         ID47=(Token)match(input,ID,FOLLOW_ID_in_resource1821); if (state.failed) return retval;
1820                                                         if ( state.backtracking==0 ) stream_ID.add(ID47);
1821
1822                                                         // AST REWRITE
1823                                                         // elements: ID
1824                                                         // token labels:
1825                                                         // rule labels: retval
1826                                                         // token list labels:
1827                                                         // rule list labels:
1828                                                         // wildcard labels:
1829                                                         if ( state.backtracking==0 ) {
1830                                                         retval.tree = root_0;
1831                                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
1832
1833                                                         root_0 = (CommonTree)adaptor.nil();
1834                                                         // 283:51: -> ^( BLANK ID )
1835                                                         {
1836                                                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:283:54: ^( BLANK ID )
1837                                                                 {
1838                                                                 CommonTree root_1 = (CommonTree)adaptor.nil();
1839                                                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(BLANK, "BLANK"), root_1);
1840                                                                 adaptor.addChild(root_1, stream_ID.nextNode());
1841                                                                 adaptor.addChild(root_0, root_1);
1842                                                                 }
1843
1844                                                         }
1845
1846
1847                                                         retval.tree = root_0;
1848                                                         }
1849
1850                                                         }
1851                                                         break;
1852                                                 case 2 :
1853                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:284:9: ID
1854                                                         {
1855                                                         ID48=(Token)match(input,ID,FOLLOW_ID_in_resource1840); if (state.failed) return retval;
1856                                                         if ( state.backtracking==0 ) stream_ID.add(ID48);
1857
1858                                                         // AST REWRITE
1859                                                         // elements: ID
1860                                                         // token labels:
1861                                                         // rule labels: retval
1862                                                         // token list labels:
1863                                                         // rule list labels:
1864                                                         // wildcard labels:
1865                                                         if ( state.backtracking==0 ) {
1866                                                         retval.tree = root_0;
1867                                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
1868
1869                                                         root_0 = (CommonTree)adaptor.nil();
1870                                                         // 284:12: -> ID
1871                                                         {
1872                                                                 adaptor.addChild(root_0, stream_ID.nextNode());
1873                                                         }
1874
1875
1876                                                         retval.tree = root_0;
1877                                                         }
1878
1879                                                         }
1880                                                         break;
1881
1882                                         }
1883
1884                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:285:7: ( '.' ( ID -> ^( REF $resource ID ) | STRING -> ^( REF $resource STRING ) ) )*
1885                                         loop18:
1886                                         while (true) {
1887                                                 int alt18=2;
1888                                                 int LA18_0 = input.LA(1);
1889                                                 if ( (LA18_0==69) ) {
1890                                                         alt18=1;
1891                                                 }
1892
1893                                                 switch (alt18) {
1894                                                 case 1 :
1895                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:285:8: '.' ( ID -> ^( REF $resource ID ) | STRING -> ^( REF $resource STRING ) )
1896                                                         {
1897                                                         char_literal49=(Token)match(input,69,FOLLOW_69_in_resource1855); if (state.failed) return retval;
1898                                                         if ( state.backtracking==0 ) stream_69.add(char_literal49);
1899
1900                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:285:12: ( ID -> ^( REF $resource ID ) | STRING -> ^( REF $resource STRING ) )
1901                                                         int alt17=2;
1902                                                         int LA17_0 = input.LA(1);
1903                                                         if ( (LA17_0==ID) ) {
1904                                                                 alt17=1;
1905                                                         }
1906                                                         else if ( (LA17_0==STRING) ) {
1907                                                                 alt17=2;
1908                                                         }
1909
1910                                                         else {
1911                                                                 if (state.backtracking>0) {state.failed=true; return retval;}
1912                                                                 NoViableAltException nvae =
1913                                                                         new NoViableAltException("", 17, 0, input);
1914                                                                 throw nvae;
1915                                                         }
1916
1917                                                         switch (alt17) {
1918                                                                 case 1 :
1919                                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:285:13: ID
1920                                                                         {
1921                                                                         ID50=(Token)match(input,ID,FOLLOW_ID_in_resource1858); if (state.failed) return retval;
1922                                                                         if ( state.backtracking==0 ) stream_ID.add(ID50);
1923
1924                                                                         // AST REWRITE
1925                                                                         // elements: ID, resource
1926                                                                         // token labels:
1927                                                                         // rule labels: retval
1928                                                                         // token list labels:
1929                                                                         // rule list labels:
1930                                                                         // wildcard labels:
1931                                                                         if ( state.backtracking==0 ) {
1932                                                                         retval.tree = root_0;
1933                                                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
1934
1935                                                                         root_0 = (CommonTree)adaptor.nil();
1936                                                                         // 285:16: -> ^( REF $resource ID )
1937                                                                         {
1938                                                                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:285:19: ^( REF $resource ID )
1939                                                                                 {
1940                                                                                 CommonTree root_1 = (CommonTree)adaptor.nil();
1941                                                                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(REF, "REF"), root_1);
1942                                                                                 adaptor.addChild(root_1, stream_retval.nextTree());
1943                                                                                 adaptor.addChild(root_1, stream_ID.nextNode());
1944                                                                                 adaptor.addChild(root_0, root_1);
1945                                                                                 }
1946
1947                                                                         }
1948
1949
1950                                                                         retval.tree = root_0;
1951                                                                         }
1952
1953                                                                         }
1954                                                                         break;
1955                                                                 case 2 :
1956                                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:286:13: STRING
1957                                                                         {
1958                                                                         STRING51=(Token)match(input,STRING,FOLLOW_STRING_in_resource1883); if (state.failed) return retval;
1959                                                                         if ( state.backtracking==0 ) stream_STRING.add(STRING51);
1960
1961                                                                         // AST REWRITE
1962                                                                         // elements: STRING, resource
1963                                                                         // token labels:
1964                                                                         // rule labels: retval
1965                                                                         // token list labels:
1966                                                                         // rule list labels:
1967                                                                         // wildcard labels:
1968                                                                         if ( state.backtracking==0 ) {
1969                                                                         retval.tree = root_0;
1970                                                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
1971
1972                                                                         root_0 = (CommonTree)adaptor.nil();
1973                                                                         // 286:20: -> ^( REF $resource STRING )
1974                                                                         {
1975                                                                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:286:23: ^( REF $resource STRING )
1976                                                                                 {
1977                                                                                 CommonTree root_1 = (CommonTree)adaptor.nil();
1978                                                                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(REF, "REF"), root_1);
1979                                                                                 adaptor.addChild(root_1, stream_retval.nextTree());
1980                                                                                 adaptor.addChild(root_1, stream_STRING.nextNode());
1981                                                                                 adaptor.addChild(root_0, root_1);
1982                                                                                 }
1983
1984                                                                         }
1985
1986
1987                                                                         retval.tree = root_0;
1988                                                                         }
1989
1990                                                                         }
1991                                                                         break;
1992
1993                                                         }
1994
1995                                                         }
1996                                                         break;
1997
1998                                                 default :
1999                                                         break loop18;
2000                                                 }
2001                                         }
2002
2003                                         }
2004                                         break;
2005                                 case 2 :
2006                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:289:7: URI
2007                                         {
2008                                         root_0 = (CommonTree)adaptor.nil();
2009
2010
2011                                         URI52=(Token)match(input,URI,FOLLOW_URI_in_resource1924); if (state.failed) return retval;
2012                                         if ( state.backtracking==0 ) {
2013                                         URI52_tree = (CommonTree)adaptor.create(URI52);
2014                                         adaptor.addChild(root_0, URI52_tree);
2015                                         }
2016
2017                                         }
2018                                         break;
2019                                 case 3 :
2020                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:290:7: simpleValue
2021                                         {
2022                                         pushFollow(FOLLOW_simpleValue_in_resource1932);
2023                                         simpleValue53=simpleValue();
2024                                         state._fsp--;
2025                                         if (state.failed) return retval;
2026                                         if ( state.backtracking==0 ) stream_simpleValue.add(simpleValue53.getTree());
2027                                         // AST REWRITE
2028                                         // elements: simpleValue
2029                                         // token labels:
2030                                         // rule labels: retval
2031                                         // token list labels:
2032                                         // rule list labels:
2033                                         // wildcard labels:
2034                                         if ( state.backtracking==0 ) {
2035                                         retval.tree = root_0;
2036                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
2037
2038                                         root_0 = (CommonTree)adaptor.nil();
2039                                         // 290:19: -> ^( EMBEDDED_VALUE simpleValue )
2040                                         {
2041                                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:290:22: ^( EMBEDDED_VALUE simpleValue )
2042                                                 {
2043                                                 CommonTree root_1 = (CommonTree)adaptor.nil();
2044                                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(EMBEDDED_VALUE, "EMBEDDED_VALUE"), root_1);
2045                                                 adaptor.addChild(root_1, stream_simpleValue.nextTree());
2046                                                 adaptor.addChild(root_0, root_1);
2047                                                 }
2048
2049                                         }
2050
2051
2052                                         retval.tree = root_0;
2053                                         }
2054
2055                                         }
2056                                         break;
2057                                 case 4 :
2058                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:291:7: '$' basicType
2059                                         {
2060                                         char_literal54=(Token)match(input,65,FOLLOW_65_in_resource1948); if (state.failed) return retval;
2061                                         if ( state.backtracking==0 ) stream_65.add(char_literal54);
2062
2063                                         pushFollow(FOLLOW_basicType_in_resource1950);
2064                                         basicType55=basicType();
2065                                         state._fsp--;
2066                                         if (state.failed) return retval;
2067                                         if ( state.backtracking==0 ) stream_basicType.add(basicType55.getTree());
2068                                         // AST REWRITE
2069                                         // elements: basicType
2070                                         // token labels:
2071                                         // rule labels: retval
2072                                         // token list labels:
2073                                         // rule list labels:
2074                                         // wildcard labels:
2075                                         if ( state.backtracking==0 ) {
2076                                         retval.tree = root_0;
2077                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
2078
2079                                         root_0 = (CommonTree)adaptor.nil();
2080                                         // 291:21: -> ^( EMBEDDED_TYPE basicType )
2081                                         {
2082                                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:291:24: ^( EMBEDDED_TYPE basicType )
2083                                                 {
2084                                                 CommonTree root_1 = (CommonTree)adaptor.nil();
2085                                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(EMBEDDED_TYPE, "EMBEDDED_TYPE"), root_1);
2086                                                 adaptor.addChild(root_1, stream_basicType.nextTree());
2087                                                 adaptor.addChild(root_0, root_1);
2088                                                 }
2089
2090                                         }
2091
2092
2093                                         retval.tree = root_0;
2094                                         }
2095
2096                                         }
2097                                         break;
2098                                 case 5 :
2099                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:292:7: '%' ID
2100                                         {
2101                                         char_literal56=(Token)match(input,66,FOLLOW_66_in_resource1966); if (state.failed) return retval;
2102                                         if ( state.backtracking==0 ) stream_66.add(char_literal56);
2103
2104                                         ID57=(Token)match(input,ID,FOLLOW_ID_in_resource1968); if (state.failed) return retval;
2105                                         if ( state.backtracking==0 ) stream_ID.add(ID57);
2106
2107                                         // AST REWRITE
2108                                         // elements: ID
2109                                         // token labels:
2110                                         // rule labels: retval
2111                                         // token list labels:
2112                                         // rule list labels:
2113                                         // wildcard labels:
2114                                         if ( state.backtracking==0 ) {
2115                                         retval.tree = root_0;
2116                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
2117
2118                                         root_0 = (CommonTree)adaptor.nil();
2119                                         // 292:14: -> ^( VARIABLE ID )
2120                                         {
2121                                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:292:17: ^( VARIABLE ID )
2122                                                 {
2123                                                 CommonTree root_1 = (CommonTree)adaptor.nil();
2124                                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(VARIABLE, "VARIABLE"), root_1);
2125                                                 adaptor.addChild(root_1, stream_ID.nextNode());
2126                                                 adaptor.addChild(root_0, root_1);
2127                                                 }
2128
2129                                         }
2130
2131
2132                                         retval.tree = root_0;
2133                                         }
2134
2135                                         }
2136                                         break;
2137
2138                         }
2139                         retval.stop = input.LT(-1);
2140
2141                         if ( state.backtracking==0 ) {
2142                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2143                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2144                         }
2145                 }
2146                 catch (RecognitionException re) {
2147                         reportError(re);
2148                         recover(input,re);
2149                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
2150                 }
2151                 finally {
2152                         // do for sure before leaving
2153                 }
2154                 return retval;
2155         }
2156         // $ANTLR end "resource"
2157
2158
2159         public static class type_return extends ParserRuleReturnScope {
2160                 CommonTree tree;
2161                 @Override
2162                 public CommonTree getTree() { return tree; }
2163         };
2164
2165
2166         // $ANTLR start "type"
2167         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:306:1: type : ( arrayType | unionType );
2168         public final GraphParser.type_return type() throws RecognitionException {
2169                 GraphParser.type_return retval = new GraphParser.type_return();
2170                 retval.start = input.LT(1);
2171
2172                 CommonTree root_0 = null;
2173
2174                 ParserRuleReturnScope arrayType58 =null;
2175                 ParserRuleReturnScope unionType59 =null;
2176
2177
2178                 try {
2179                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:307:5: ( arrayType | unionType )
2180                         int alt20=2;
2181                         int LA20_0 = input.LA(1);
2182                         if ( (LA20_0==ID||(LA20_0 >= LCURLY && LA20_0 <= LPAREN)) ) {
2183                                 alt20=1;
2184                         }
2185                         else if ( (LA20_0==80) ) {
2186                                 alt20=2;
2187                         }
2188
2189                         else {
2190                                 if (state.backtracking>0) {state.failed=true; return retval;}
2191                                 NoViableAltException nvae =
2192                                         new NoViableAltException("", 20, 0, input);
2193                                 throw nvae;
2194                         }
2195
2196                         switch (alt20) {
2197                                 case 1 :
2198                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:307:7: arrayType
2199                                         {
2200                                         root_0 = (CommonTree)adaptor.nil();
2201
2202
2203                                         pushFollow(FOLLOW_arrayType_in_type2004);
2204                                         arrayType58=arrayType();
2205                                         state._fsp--;
2206                                         if (state.failed) return retval;
2207                                         if ( state.backtracking==0 ) adaptor.addChild(root_0, arrayType58.getTree());
2208
2209                                         }
2210                                         break;
2211                                 case 2 :
2212                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:308:7: unionType
2213                                         {
2214                                         root_0 = (CommonTree)adaptor.nil();
2215
2216
2217                                         pushFollow(FOLLOW_unionType_in_type2012);
2218                                         unionType59=unionType();
2219                                         state._fsp--;
2220                                         if (state.failed) return retval;
2221                                         if ( state.backtracking==0 ) adaptor.addChild(root_0, unionType59.getTree());
2222
2223                                         }
2224                                         break;
2225
2226                         }
2227                         retval.stop = input.LT(-1);
2228
2229                         if ( state.backtracking==0 ) {
2230                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2231                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2232                         }
2233                 }
2234                 catch (RecognitionException re) {
2235                         reportError(re);
2236                         recover(input,re);
2237                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
2238                 }
2239                 finally {
2240                         // do for sure before leaving
2241                 }
2242                 return retval;
2243         }
2244         // $ANTLR end "type"
2245
2246
2247         public static class unionType_return extends ParserRuleReturnScope {
2248                 CommonTree tree;
2249                 @Override
2250                 public CommonTree getTree() { return tree; }
2251         };
2252
2253
2254         // $ANTLR start "unionType"
2255         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:311:1: unionType : ( '|' unionComponent )+ -> ^( UNION_TYPE ( unionComponent )+ ) ;
2256         public final GraphParser.unionType_return unionType() throws RecognitionException {
2257                 GraphParser.unionType_return retval = new GraphParser.unionType_return();
2258                 retval.start = input.LT(1);
2259
2260                 CommonTree root_0 = null;
2261
2262                 Token char_literal60=null;
2263                 ParserRuleReturnScope unionComponent61 =null;
2264
2265                 CommonTree char_literal60_tree=null;
2266                 RewriteRuleTokenStream stream_80=new RewriteRuleTokenStream(adaptor,"token 80");
2267                 RewriteRuleSubtreeStream stream_unionComponent=new RewriteRuleSubtreeStream(adaptor,"rule unionComponent");
2268
2269                 try {
2270                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:312:5: ( ( '|' unionComponent )+ -> ^( UNION_TYPE ( unionComponent )+ ) )
2271                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:313:6: ( '|' unionComponent )+
2272                         {
2273                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:313:6: ( '|' unionComponent )+
2274                         int cnt21=0;
2275                         loop21:
2276                         while (true) {
2277                                 int alt21=2;
2278                                 int LA21_0 = input.LA(1);
2279                                 if ( (LA21_0==80) ) {
2280                                         alt21=1;
2281                                 }
2282
2283                                 switch (alt21) {
2284                                 case 1 :
2285                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:313:7: '|' unionComponent
2286                                         {
2287                                         char_literal60=(Token)match(input,80,FOLLOW_80_in_unionType2041); if (state.failed) return retval;
2288                                         if ( state.backtracking==0 ) stream_80.add(char_literal60);
2289
2290                                         pushFollow(FOLLOW_unionComponent_in_unionType2043);
2291                                         unionComponent61=unionComponent();
2292                                         state._fsp--;
2293                                         if (state.failed) return retval;
2294                                         if ( state.backtracking==0 ) stream_unionComponent.add(unionComponent61.getTree());
2295                                         }
2296                                         break;
2297
2298                                 default :
2299                                         if ( cnt21 >= 1 ) break loop21;
2300                                         if (state.backtracking>0) {state.failed=true; return retval;}
2301                                         EarlyExitException eee = new EarlyExitException(21, input);
2302                                         throw eee;
2303                                 }
2304                                 cnt21++;
2305                         }
2306
2307                         // AST REWRITE
2308                         // elements: unionComponent
2309                         // token labels:
2310                         // rule labels: retval
2311                         // token list labels:
2312                         // rule list labels:
2313                         // wildcard labels:
2314                         if ( state.backtracking==0 ) {
2315                         retval.tree = root_0;
2316                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
2317
2318                         root_0 = (CommonTree)adaptor.nil();
2319                         // 314:5: -> ^( UNION_TYPE ( unionComponent )+ )
2320                         {
2321                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:314:8: ^( UNION_TYPE ( unionComponent )+ )
2322                                 {
2323                                 CommonTree root_1 = (CommonTree)adaptor.nil();
2324                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(UNION_TYPE, "UNION_TYPE"), root_1);
2325                                 if ( !(stream_unionComponent.hasNext()) ) {
2326                                         throw new RewriteEarlyExitException();
2327                                 }
2328                                 while ( stream_unionComponent.hasNext() ) {
2329                                         adaptor.addChild(root_1, stream_unionComponent.nextTree());
2330                                 }
2331                                 stream_unionComponent.reset();
2332
2333                                 adaptor.addChild(root_0, root_1);
2334                                 }
2335
2336                         }
2337
2338
2339                         retval.tree = root_0;
2340                         }
2341
2342                         }
2343
2344                         retval.stop = input.LT(-1);
2345
2346                         if ( state.backtracking==0 ) {
2347                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2348                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2349                         }
2350                 }
2351                 catch (RecognitionException re) {
2352                         reportError(re);
2353                         recover(input,re);
2354                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
2355                 }
2356                 finally {
2357                         // do for sure before leaving
2358                 }
2359                 return retval;
2360         }
2361         // $ANTLR end "unionType"
2362
2363
2364         public static class unionComponent_return extends ParserRuleReturnScope {
2365                 CommonTree tree;
2366                 @Override
2367                 public CommonTree getTree() { return tree; }
2368         };
2369
2370
2371         // $ANTLR start "unionComponent"
2372         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:317:1: unionComponent : ID ( ( arrayType )=> arrayType )? -> ^( TYPE_COMPONENT ID ( arrayType )? ) ;
2373         public final GraphParser.unionComponent_return unionComponent() throws RecognitionException {
2374                 GraphParser.unionComponent_return retval = new GraphParser.unionComponent_return();
2375                 retval.start = input.LT(1);
2376
2377                 CommonTree root_0 = null;
2378
2379                 Token ID62=null;
2380                 ParserRuleReturnScope arrayType63 =null;
2381
2382                 CommonTree ID62_tree=null;
2383                 RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
2384                 RewriteRuleSubtreeStream stream_arrayType=new RewriteRuleSubtreeStream(adaptor,"rule arrayType");
2385
2386                 try {
2387                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:317:16: ( ID ( ( arrayType )=> arrayType )? -> ^( TYPE_COMPONENT ID ( arrayType )? ) )
2388                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:317:18: ID ( ( arrayType )=> arrayType )?
2389                         {
2390                         ID62=(Token)match(input,ID,FOLLOW_ID_in_unionComponent2071); if (state.failed) return retval;
2391                         if ( state.backtracking==0 ) stream_ID.add(ID62);
2392
2393                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:317:21: ( ( arrayType )=> arrayType )?
2394                         int alt22=2;
2395                         int LA22_0 = input.LA(1);
2396                         if ( (LA22_0==LPAREN) && (synpred1_Graph())) {
2397                                 alt22=1;
2398                         }
2399                         else if ( (LA22_0==LCURLY) && (synpred1_Graph())) {
2400                                 alt22=1;
2401                         }
2402                         else if ( (LA22_0==ID) ) {
2403                                 int LA22_3 = input.LA(2);
2404                                 if ( (synpred1_Graph()) ) {
2405                                         alt22=1;
2406                                 }
2407                         }
2408                         switch (alt22) {
2409                                 case 1 :
2410                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:317:22: ( arrayType )=> arrayType
2411                                         {
2412                                         pushFollow(FOLLOW_arrayType_in_unionComponent2080);
2413                                         arrayType63=arrayType();
2414                                         state._fsp--;
2415                                         if (state.failed) return retval;
2416                                         if ( state.backtracking==0 ) stream_arrayType.add(arrayType63.getTree());
2417                                         }
2418                                         break;
2419
2420                         }
2421
2422                         // AST REWRITE
2423                         // elements: ID, arrayType
2424                         // token labels:
2425                         // rule labels: retval
2426                         // token list labels:
2427                         // rule list labels:
2428                         // wildcard labels:
2429                         if ( state.backtracking==0 ) {
2430                         retval.tree = root_0;
2431                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
2432
2433                         root_0 = (CommonTree)adaptor.nil();
2434                         // 317:49: -> ^( TYPE_COMPONENT ID ( arrayType )? )
2435                         {
2436                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:317:52: ^( TYPE_COMPONENT ID ( arrayType )? )
2437                                 {
2438                                 CommonTree root_1 = (CommonTree)adaptor.nil();
2439                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPE_COMPONENT, "TYPE_COMPONENT"), root_1);
2440                                 adaptor.addChild(root_1, stream_ID.nextNode());
2441                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:317:72: ( arrayType )?
2442                                 if ( stream_arrayType.hasNext() ) {
2443                                         adaptor.addChild(root_1, stream_arrayType.nextTree());
2444                                 }
2445                                 stream_arrayType.reset();
2446
2447                                 adaptor.addChild(root_0, root_1);
2448                                 }
2449
2450                         }
2451
2452
2453                         retval.tree = root_0;
2454                         }
2455
2456                         }
2457
2458                         retval.stop = input.LT(-1);
2459
2460                         if ( state.backtracking==0 ) {
2461                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2462                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2463                         }
2464                 }
2465                 catch (RecognitionException re) {
2466                         reportError(re);
2467                         recover(input,re);
2468                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
2469                 }
2470                 finally {
2471                         // do for sure before leaving
2472                 }
2473                 return retval;
2474         }
2475         // $ANTLR end "unionComponent"
2476
2477
2478         public static class arrayType_return extends ParserRuleReturnScope {
2479                 CommonTree tree;
2480                 @Override
2481                 public CommonTree getTree() { return tree; }
2482         };
2483
2484
2485         // $ANTLR start "arrayType"
2486         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:319:1: arrayType : ( basicType -> basicType ) ( LBRACKET ( arrayLength )? RBRACKET -> ^( ARRAY_TYPE $arrayType ( arrayLength )? ) )* ;
2487         public final GraphParser.arrayType_return arrayType() throws RecognitionException {
2488                 GraphParser.arrayType_return retval = new GraphParser.arrayType_return();
2489                 retval.start = input.LT(1);
2490
2491                 CommonTree root_0 = null;
2492
2493                 Token LBRACKET65=null;
2494                 Token RBRACKET67=null;
2495                 ParserRuleReturnScope basicType64 =null;
2496                 ParserRuleReturnScope arrayLength66 =null;
2497
2498                 CommonTree LBRACKET65_tree=null;
2499                 CommonTree RBRACKET67_tree=null;
2500                 RewriteRuleTokenStream stream_LBRACKET=new RewriteRuleTokenStream(adaptor,"token LBRACKET");
2501                 RewriteRuleTokenStream stream_RBRACKET=new RewriteRuleTokenStream(adaptor,"token RBRACKET");
2502                 RewriteRuleSubtreeStream stream_basicType=new RewriteRuleSubtreeStream(adaptor,"rule basicType");
2503                 RewriteRuleSubtreeStream stream_arrayLength=new RewriteRuleSubtreeStream(adaptor,"rule arrayLength");
2504
2505                 try {
2506                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:320:5: ( ( basicType -> basicType ) ( LBRACKET ( arrayLength )? RBRACKET -> ^( ARRAY_TYPE $arrayType ( arrayLength )? ) )* )
2507                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:320:7: ( basicType -> basicType ) ( LBRACKET ( arrayLength )? RBRACKET -> ^( ARRAY_TYPE $arrayType ( arrayLength )? ) )*
2508                         {
2509                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:320:7: ( basicType -> basicType )
2510                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:320:8: basicType
2511                         {
2512                         pushFollow(FOLLOW_basicType_in_arrayType2108);
2513                         basicType64=basicType();
2514                         state._fsp--;
2515                         if (state.failed) return retval;
2516                         if ( state.backtracking==0 ) stream_basicType.add(basicType64.getTree());
2517                         // AST REWRITE
2518                         // elements: basicType
2519                         // token labels:
2520                         // rule labels: retval
2521                         // token list labels:
2522                         // rule list labels:
2523                         // wildcard labels:
2524                         if ( state.backtracking==0 ) {
2525                         retval.tree = root_0;
2526                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
2527
2528                         root_0 = (CommonTree)adaptor.nil();
2529                         // 320:18: -> basicType
2530                         {
2531                                 adaptor.addChild(root_0, stream_basicType.nextTree());
2532                         }
2533
2534
2535                         retval.tree = root_0;
2536                         }
2537
2538                         }
2539
2540                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:321:7: ( LBRACKET ( arrayLength )? RBRACKET -> ^( ARRAY_TYPE $arrayType ( arrayLength )? ) )*
2541                         loop24:
2542                         while (true) {
2543                                 int alt24=2;
2544                                 int LA24_0 = input.LA(1);
2545                                 if ( (LA24_0==LBRACKET) ) {
2546                                         alt24=1;
2547                                 }
2548
2549                                 switch (alt24) {
2550                                 case 1 :
2551                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:321:8: LBRACKET ( arrayLength )? RBRACKET
2552                                         {
2553                                         LBRACKET65=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayType2122); if (state.failed) return retval;
2554                                         if ( state.backtracking==0 ) stream_LBRACKET.add(LBRACKET65);
2555
2556                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:321:17: ( arrayLength )?
2557                                         int alt23=2;
2558                                         int LA23_0 = input.LA(1);
2559                                         if ( ((LA23_0 >= INT && LA23_0 <= INT_RANGE)) ) {
2560                                                 alt23=1;
2561                                         }
2562                                         switch (alt23) {
2563                                                 case 1 :
2564                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:321:17: arrayLength
2565                                                         {
2566                                                         pushFollow(FOLLOW_arrayLength_in_arrayType2124);
2567                                                         arrayLength66=arrayLength();
2568                                                         state._fsp--;
2569                                                         if (state.failed) return retval;
2570                                                         if ( state.backtracking==0 ) stream_arrayLength.add(arrayLength66.getTree());
2571                                                         }
2572                                                         break;
2573
2574                                         }
2575
2576                                         RBRACKET67=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayType2127); if (state.failed) return retval;
2577                                         if ( state.backtracking==0 ) stream_RBRACKET.add(RBRACKET67);
2578
2579                                         // AST REWRITE
2580                                         // elements: arrayLength, arrayType
2581                                         // token labels:
2582                                         // rule labels: retval
2583                                         // token list labels:
2584                                         // rule list labels:
2585                                         // wildcard labels:
2586                                         if ( state.backtracking==0 ) {
2587                                         retval.tree = root_0;
2588                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
2589
2590                                         root_0 = (CommonTree)adaptor.nil();
2591                                         // 321:39: -> ^( ARRAY_TYPE $arrayType ( arrayLength )? )
2592                                         {
2593                                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:321:42: ^( ARRAY_TYPE $arrayType ( arrayLength )? )
2594                                                 {
2595                                                 CommonTree root_1 = (CommonTree)adaptor.nil();
2596                                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ARRAY_TYPE, "ARRAY_TYPE"), root_1);
2597                                                 adaptor.addChild(root_1, stream_retval.nextTree());
2598                                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:321:66: ( arrayLength )?
2599                                                 if ( stream_arrayLength.hasNext() ) {
2600                                                         adaptor.addChild(root_1, stream_arrayLength.nextTree());
2601                                                 }
2602                                                 stream_arrayLength.reset();
2603
2604                                                 adaptor.addChild(root_0, root_1);
2605                                                 }
2606
2607                                         }
2608
2609
2610                                         retval.tree = root_0;
2611                                         }
2612
2613                                         }
2614                                         break;
2615
2616                                 default :
2617                                         break loop24;
2618                                 }
2619                         }
2620
2621                         }
2622
2623                         retval.stop = input.LT(-1);
2624
2625                         if ( state.backtracking==0 ) {
2626                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2627                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2628                         }
2629                 }
2630                 catch (RecognitionException re) {
2631                         reportError(re);
2632                         recover(input,re);
2633                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
2634                 }
2635                 finally {
2636                         // do for sure before leaving
2637                 }
2638                 return retval;
2639         }
2640         // $ANTLR end "arrayType"
2641
2642
2643         public static class arrayLength_return extends ParserRuleReturnScope {
2644                 CommonTree tree;
2645                 @Override
2646                 public CommonTree getTree() { return tree; }
2647         };
2648
2649
2650         // $ANTLR start "arrayLength"
2651         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:323:1: arrayLength : ( INT | INT_RANGE );
2652         public final GraphParser.arrayLength_return arrayLength() throws RecognitionException {
2653                 GraphParser.arrayLength_return retval = new GraphParser.arrayLength_return();
2654                 retval.start = input.LT(1);
2655
2656                 CommonTree root_0 = null;
2657
2658                 Token set68=null;
2659
2660                 CommonTree set68_tree=null;
2661
2662                 try {
2663                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:324:5: ( INT | INT_RANGE )
2664                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:
2665                         {
2666                         root_0 = (CommonTree)adaptor.nil();
2667
2668
2669                         set68=input.LT(1);
2670                         if ( (input.LA(1) >= INT && input.LA(1) <= INT_RANGE) ) {
2671                                 input.consume();
2672                                 if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set68));
2673                                 state.errorRecovery=false;
2674                                 state.failed=false;
2675                         }
2676                         else {
2677                                 if (state.backtracking>0) {state.failed=true; return retval;}
2678                                 MismatchedSetException mse = new MismatchedSetException(null,input);
2679                                 throw mse;
2680                         }
2681                         }
2682
2683                         retval.stop = input.LT(-1);
2684
2685                         if ( state.backtracking==0 ) {
2686                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2687                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2688                         }
2689                 }
2690                 catch (RecognitionException re) {
2691                         reportError(re);
2692                         recover(input,re);
2693                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
2694                 }
2695                 finally {
2696                         // do for sure before leaving
2697                 }
2698                 return retval;
2699         }
2700         // $ANTLR end "arrayLength"
2701
2702
2703         public static class basicType_return extends ParserRuleReturnScope {
2704                 CommonTree tree;
2705                 @Override
2706                 public CommonTree getTree() { return tree; }
2707         };
2708
2709
2710         // $ANTLR start "basicType"
2711         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:328:1: basicType : ( tupleType | recordType | typeReference );
2712         public final GraphParser.basicType_return basicType() throws RecognitionException {
2713                 GraphParser.basicType_return retval = new GraphParser.basicType_return();
2714                 retval.start = input.LT(1);
2715
2716                 CommonTree root_0 = null;
2717
2718                 ParserRuleReturnScope tupleType69 =null;
2719                 ParserRuleReturnScope recordType70 =null;
2720                 ParserRuleReturnScope typeReference71 =null;
2721
2722
2723                 try {
2724                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:329:5: ( tupleType | recordType | typeReference )
2725                         int alt25=3;
2726                         switch ( input.LA(1) ) {
2727                         case LPAREN:
2728                                 {
2729                                 alt25=1;
2730                                 }
2731                                 break;
2732                         case LCURLY:
2733                                 {
2734                                 alt25=2;
2735                                 }
2736                                 break;
2737                         case ID:
2738                                 {
2739                                 alt25=3;
2740                                 }
2741                                 break;
2742                         default:
2743                                 if (state.backtracking>0) {state.failed=true; return retval;}
2744                                 NoViableAltException nvae =
2745                                         new NoViableAltException("", 25, 0, input);
2746                                 throw nvae;
2747                         }
2748                         switch (alt25) {
2749                                 case 1 :
2750                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:329:7: tupleType
2751                                         {
2752                                         root_0 = (CommonTree)adaptor.nil();
2753
2754
2755                                         pushFollow(FOLLOW_tupleType_in_basicType2181);
2756                                         tupleType69=tupleType();
2757                                         state._fsp--;
2758                                         if (state.failed) return retval;
2759                                         if ( state.backtracking==0 ) adaptor.addChild(root_0, tupleType69.getTree());
2760
2761                                         }
2762                                         break;
2763                                 case 2 :
2764                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:330:7: recordType
2765                                         {
2766                                         root_0 = (CommonTree)adaptor.nil();
2767
2768
2769                                         pushFollow(FOLLOW_recordType_in_basicType2189);
2770                                         recordType70=recordType();
2771                                         state._fsp--;
2772                                         if (state.failed) return retval;
2773                                         if ( state.backtracking==0 ) adaptor.addChild(root_0, recordType70.getTree());
2774
2775                                         }
2776                                         break;
2777                                 case 3 :
2778                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:331:7: typeReference
2779                                         {
2780                                         root_0 = (CommonTree)adaptor.nil();
2781
2782
2783                                         pushFollow(FOLLOW_typeReference_in_basicType2197);
2784                                         typeReference71=typeReference();
2785                                         state._fsp--;
2786                                         if (state.failed) return retval;
2787                                         if ( state.backtracking==0 ) adaptor.addChild(root_0, typeReference71.getTree());
2788
2789                                         }
2790                                         break;
2791
2792                         }
2793                         retval.stop = input.LT(-1);
2794
2795                         if ( state.backtracking==0 ) {
2796                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2797                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2798                         }
2799                 }
2800                 catch (RecognitionException re) {
2801                         reportError(re);
2802                         recover(input,re);
2803                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
2804                 }
2805                 finally {
2806                         // do for sure before leaving
2807                 }
2808                 return retval;
2809         }
2810         // $ANTLR end "basicType"
2811
2812
2813         public static class tupleType_return extends ParserRuleReturnScope {
2814                 CommonTree tree;
2815                 @Override
2816                 public CommonTree getTree() { return tree; }
2817         };
2818
2819
2820         // $ANTLR start "tupleType"
2821         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:334:1: tupleType : LPAREN ( type ( ',' type )* )? RPAREN -> ^( TUPLE_TYPE ( type )* ) ;
2822         public final GraphParser.tupleType_return tupleType() throws RecognitionException {
2823                 GraphParser.tupleType_return retval = new GraphParser.tupleType_return();
2824                 retval.start = input.LT(1);
2825
2826                 CommonTree root_0 = null;
2827
2828                 Token LPAREN72=null;
2829                 Token char_literal74=null;
2830                 Token RPAREN76=null;
2831                 ParserRuleReturnScope type73 =null;
2832                 ParserRuleReturnScope type75 =null;
2833
2834                 CommonTree LPAREN72_tree=null;
2835                 CommonTree char_literal74_tree=null;
2836                 CommonTree RPAREN76_tree=null;
2837                 RewriteRuleTokenStream stream_67=new RewriteRuleTokenStream(adaptor,"token 67");
2838                 RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
2839                 RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
2840                 RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
2841
2842                 try {
2843                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:335:5: ( LPAREN ( type ( ',' type )* )? RPAREN -> ^( TUPLE_TYPE ( type )* ) )
2844                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:335:7: LPAREN ( type ( ',' type )* )? RPAREN
2845                         {
2846                         LPAREN72=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_tupleType2219); if (state.failed) return retval;
2847                         if ( state.backtracking==0 ) stream_LPAREN.add(LPAREN72);
2848
2849                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:335:14: ( type ( ',' type )* )?
2850                         int alt27=2;
2851                         int LA27_0 = input.LA(1);
2852                         if ( (LA27_0==ID||(LA27_0 >= LCURLY && LA27_0 <= LPAREN)||LA27_0==80) ) {
2853                                 alt27=1;
2854                         }
2855                         switch (alt27) {
2856                                 case 1 :
2857                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:335:15: type ( ',' type )*
2858                                         {
2859                                         pushFollow(FOLLOW_type_in_tupleType2222);
2860                                         type73=type();
2861                                         state._fsp--;
2862                                         if (state.failed) return retval;
2863                                         if ( state.backtracking==0 ) stream_type.add(type73.getTree());
2864                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:335:20: ( ',' type )*
2865                                         loop26:
2866                                         while (true) {
2867                                                 int alt26=2;
2868                                                 int LA26_0 = input.LA(1);
2869                                                 if ( (LA26_0==67) ) {
2870                                                         alt26=1;
2871                                                 }
2872
2873                                                 switch (alt26) {
2874                                                 case 1 :
2875                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:335:21: ',' type
2876                                                         {
2877                                                         char_literal74=(Token)match(input,67,FOLLOW_67_in_tupleType2225); if (state.failed) return retval;
2878                                                         if ( state.backtracking==0 ) stream_67.add(char_literal74);
2879
2880                                                         pushFollow(FOLLOW_type_in_tupleType2227);
2881                                                         type75=type();
2882                                                         state._fsp--;
2883                                                         if (state.failed) return retval;
2884                                                         if ( state.backtracking==0 ) stream_type.add(type75.getTree());
2885                                                         }
2886                                                         break;
2887
2888                                                 default :
2889                                                         break loop26;
2890                                                 }
2891                                         }
2892
2893                                         }
2894                                         break;
2895
2896                         }
2897
2898                         RPAREN76=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_tupleType2233); if (state.failed) return retval;
2899                         if ( state.backtracking==0 ) stream_RPAREN.add(RPAREN76);
2900
2901                         // AST REWRITE
2902                         // elements: type
2903                         // token labels:
2904                         // rule labels: retval
2905                         // token list labels:
2906                         // rule list labels:
2907                         // wildcard labels:
2908                         if ( state.backtracking==0 ) {
2909                         retval.tree = root_0;
2910                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
2911
2912                         root_0 = (CommonTree)adaptor.nil();
2913                         // 336:5: -> ^( TUPLE_TYPE ( type )* )
2914                         {
2915                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:336:8: ^( TUPLE_TYPE ( type )* )
2916                                 {
2917                                 CommonTree root_1 = (CommonTree)adaptor.nil();
2918                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TUPLE_TYPE, "TUPLE_TYPE"), root_1);
2919                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:336:21: ( type )*
2920                                 while ( stream_type.hasNext() ) {
2921                                         adaptor.addChild(root_1, stream_type.nextTree());
2922                                 }
2923                                 stream_type.reset();
2924
2925                                 adaptor.addChild(root_0, root_1);
2926                                 }
2927
2928                         }
2929
2930
2931                         retval.tree = root_0;
2932                         }
2933
2934                         }
2935
2936                         retval.stop = input.LT(-1);
2937
2938                         if ( state.backtracking==0 ) {
2939                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2940                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2941                         }
2942                 }
2943                 catch (RecognitionException re) {
2944                         reportError(re);
2945                         recover(input,re);
2946                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
2947                 }
2948                 finally {
2949                         // do for sure before leaving
2950                 }
2951                 return retval;
2952         }
2953         // $ANTLR end "tupleType"
2954
2955
2956         public static class recordType_return extends ParserRuleReturnScope {
2957                 CommonTree tree;
2958                 @Override
2959                 public CommonTree getTree() { return tree; }
2960         };
2961
2962
2963         // $ANTLR start "recordType"
2964         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:339:1: recordType : LCURLY ( component ( ',' component )* )? RCURLY -> ^( RECORD_TYPE ( component )* ) ;
2965         public final GraphParser.recordType_return recordType() throws RecognitionException {
2966                 GraphParser.recordType_return retval = new GraphParser.recordType_return();
2967                 retval.start = input.LT(1);
2968
2969                 CommonTree root_0 = null;
2970
2971                 Token LCURLY77=null;
2972                 Token char_literal79=null;
2973                 Token RCURLY81=null;
2974                 ParserRuleReturnScope component78 =null;
2975                 ParserRuleReturnScope component80 =null;
2976
2977                 CommonTree LCURLY77_tree=null;
2978                 CommonTree char_literal79_tree=null;
2979                 CommonTree RCURLY81_tree=null;
2980                 RewriteRuleTokenStream stream_67=new RewriteRuleTokenStream(adaptor,"token 67");
2981                 RewriteRuleTokenStream stream_LCURLY=new RewriteRuleTokenStream(adaptor,"token LCURLY");
2982                 RewriteRuleTokenStream stream_RCURLY=new RewriteRuleTokenStream(adaptor,"token RCURLY");
2983                 RewriteRuleSubtreeStream stream_component=new RewriteRuleSubtreeStream(adaptor,"rule component");
2984
2985                 try {
2986                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:340:5: ( LCURLY ( component ( ',' component )* )? RCURLY -> ^( RECORD_TYPE ( component )* ) )
2987                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:340:7: LCURLY ( component ( ',' component )* )? RCURLY
2988                         {
2989                         LCURLY77=(Token)match(input,LCURLY,FOLLOW_LCURLY_in_recordType2266); if (state.failed) return retval;
2990                         if ( state.backtracking==0 ) stream_LCURLY.add(LCURLY77);
2991
2992                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:340:14: ( component ( ',' component )* )?
2993                         int alt29=2;
2994                         int LA29_0 = input.LA(1);
2995                         if ( (LA29_0==ID) ) {
2996                                 alt29=1;
2997                         }
2998                         switch (alt29) {
2999                                 case 1 :
3000                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:340:15: component ( ',' component )*
3001                                         {
3002                                         pushFollow(FOLLOW_component_in_recordType2269);
3003                                         component78=component();
3004                                         state._fsp--;
3005                                         if (state.failed) return retval;
3006                                         if ( state.backtracking==0 ) stream_component.add(component78.getTree());
3007                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:340:25: ( ',' component )*
3008                                         loop28:
3009                                         while (true) {
3010                                                 int alt28=2;
3011                                                 int LA28_0 = input.LA(1);
3012                                                 if ( (LA28_0==67) ) {
3013                                                         alt28=1;
3014                                                 }
3015
3016                                                 switch (alt28) {
3017                                                 case 1 :
3018                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:340:26: ',' component
3019                                                         {
3020                                                         char_literal79=(Token)match(input,67,FOLLOW_67_in_recordType2272); if (state.failed) return retval;
3021                                                         if ( state.backtracking==0 ) stream_67.add(char_literal79);
3022
3023                                                         pushFollow(FOLLOW_component_in_recordType2274);
3024                                                         component80=component();
3025                                                         state._fsp--;
3026                                                         if (state.failed) return retval;
3027                                                         if ( state.backtracking==0 ) stream_component.add(component80.getTree());
3028                                                         }
3029                                                         break;
3030
3031                                                 default :
3032                                                         break loop28;
3033                                                 }
3034                                         }
3035
3036                                         }
3037                                         break;
3038
3039                         }
3040
3041                         RCURLY81=(Token)match(input,RCURLY,FOLLOW_RCURLY_in_recordType2280); if (state.failed) return retval;
3042                         if ( state.backtracking==0 ) stream_RCURLY.add(RCURLY81);
3043
3044                         // AST REWRITE
3045                         // elements: component
3046                         // token labels:
3047                         // rule labels: retval
3048                         // token list labels:
3049                         // rule list labels:
3050                         // wildcard labels:
3051                         if ( state.backtracking==0 ) {
3052                         retval.tree = root_0;
3053                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
3054
3055                         root_0 = (CommonTree)adaptor.nil();
3056                         // 341:5: -> ^( RECORD_TYPE ( component )* )
3057                         {
3058                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:341:8: ^( RECORD_TYPE ( component )* )
3059                                 {
3060                                 CommonTree root_1 = (CommonTree)adaptor.nil();
3061                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(RECORD_TYPE, "RECORD_TYPE"), root_1);
3062                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:341:22: ( component )*
3063                                 while ( stream_component.hasNext() ) {
3064                                         adaptor.addChild(root_1, stream_component.nextTree());
3065                                 }
3066                                 stream_component.reset();
3067
3068                                 adaptor.addChild(root_0, root_1);
3069                                 }
3070
3071                         }
3072
3073
3074                         retval.tree = root_0;
3075                         }
3076
3077                         }
3078
3079                         retval.stop = input.LT(-1);
3080
3081                         if ( state.backtracking==0 ) {
3082                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
3083                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3084                         }
3085                 }
3086                 catch (RecognitionException re) {
3087                         reportError(re);
3088                         recover(input,re);
3089                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
3090                 }
3091                 finally {
3092                         // do for sure before leaving
3093                 }
3094                 return retval;
3095         }
3096         // $ANTLR end "recordType"
3097
3098
3099         public static class component_return extends ParserRuleReturnScope {
3100                 CommonTree tree;
3101                 @Override
3102                 public CommonTree getTree() { return tree; }
3103         };
3104
3105
3106         // $ANTLR start "component"
3107         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:344:1: component : ID ':' type -> ^( TYPE_COMPONENT ID type ) ;
3108         public final GraphParser.component_return component() throws RecognitionException {
3109                 GraphParser.component_return retval = new GraphParser.component_return();
3110                 retval.start = input.LT(1);
3111
3112                 CommonTree root_0 = null;
3113
3114                 Token ID82=null;
3115                 Token char_literal83=null;
3116                 ParserRuleReturnScope type84 =null;
3117
3118                 CommonTree ID82_tree=null;
3119                 CommonTree char_literal83_tree=null;
3120                 RewriteRuleTokenStream stream_70=new RewriteRuleTokenStream(adaptor,"token 70");
3121                 RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
3122                 RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
3123
3124                 try {
3125                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:345:5: ( ID ':' type -> ^( TYPE_COMPONENT ID type ) )
3126                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:345:7: ID ':' type
3127                         {
3128                         ID82=(Token)match(input,ID,FOLLOW_ID_in_component2312); if (state.failed) return retval;
3129                         if ( state.backtracking==0 ) stream_ID.add(ID82);
3130
3131                         char_literal83=(Token)match(input,70,FOLLOW_70_in_component2314); if (state.failed) return retval;
3132                         if ( state.backtracking==0 ) stream_70.add(char_literal83);
3133
3134                         pushFollow(FOLLOW_type_in_component2316);
3135                         type84=type();
3136                         state._fsp--;
3137                         if (state.failed) return retval;
3138                         if ( state.backtracking==0 ) stream_type.add(type84.getTree());
3139                         // AST REWRITE
3140                         // elements: type, ID
3141                         // token labels:
3142                         // rule labels: retval
3143                         // token list labels:
3144                         // rule list labels:
3145                         // wildcard labels:
3146                         if ( state.backtracking==0 ) {
3147                         retval.tree = root_0;
3148                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
3149
3150                         root_0 = (CommonTree)adaptor.nil();
3151                         // 346:5: -> ^( TYPE_COMPONENT ID type )
3152                         {
3153                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:346:8: ^( TYPE_COMPONENT ID type )
3154                                 {
3155                                 CommonTree root_1 = (CommonTree)adaptor.nil();
3156                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPE_COMPONENT, "TYPE_COMPONENT"), root_1);
3157                                 adaptor.addChild(root_1, stream_ID.nextNode());
3158                                 adaptor.addChild(root_1, stream_type.nextTree());
3159                                 adaptor.addChild(root_0, root_1);
3160                                 }
3161
3162                         }
3163
3164
3165                         retval.tree = root_0;
3166                         }
3167
3168                         }
3169
3170                         retval.stop = input.LT(-1);
3171
3172                         if ( state.backtracking==0 ) {
3173                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
3174                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3175                         }
3176                 }
3177                 catch (RecognitionException re) {
3178                         reportError(re);
3179                         recover(input,re);
3180                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
3181                 }
3182                 finally {
3183                         // do for sure before leaving
3184                 }
3185                 return retval;
3186         }
3187         // $ANTLR end "component"
3188
3189
3190         public static class typeReference_return extends ParserRuleReturnScope {
3191                 CommonTree tree;
3192                 @Override
3193                 public CommonTree getTree() { return tree; }
3194         };
3195
3196
3197         // $ANTLR start "typeReference"
3198         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:349:1: typeReference : ID ( ( LPAREN )=> LPAREN parameter ( ',' parameter )* RPAREN )? -> ^( TYPE_REFERENCE ID ( parameter )* ) ;
3199         public final GraphParser.typeReference_return typeReference() throws RecognitionException {
3200                 GraphParser.typeReference_return retval = new GraphParser.typeReference_return();
3201                 retval.start = input.LT(1);
3202
3203                 CommonTree root_0 = null;
3204
3205                 Token ID85=null;
3206                 Token LPAREN86=null;
3207                 Token char_literal88=null;
3208                 Token RPAREN90=null;
3209                 ParserRuleReturnScope parameter87 =null;
3210                 ParserRuleReturnScope parameter89 =null;
3211
3212                 CommonTree ID85_tree=null;
3213                 CommonTree LPAREN86_tree=null;
3214                 CommonTree char_literal88_tree=null;
3215                 CommonTree RPAREN90_tree=null;
3216                 RewriteRuleTokenStream stream_67=new RewriteRuleTokenStream(adaptor,"token 67");
3217                 RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
3218                 RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
3219                 RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
3220                 RewriteRuleSubtreeStream stream_parameter=new RewriteRuleSubtreeStream(adaptor,"rule parameter");
3221
3222                 try {
3223                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:350:5: ( ID ( ( LPAREN )=> LPAREN parameter ( ',' parameter )* RPAREN )? -> ^( TYPE_REFERENCE ID ( parameter )* ) )
3224                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:350:7: ID ( ( LPAREN )=> LPAREN parameter ( ',' parameter )* RPAREN )?
3225                         {
3226                         ID85=(Token)match(input,ID,FOLLOW_ID_in_typeReference2350); if (state.failed) return retval;
3227                         if ( state.backtracking==0 ) stream_ID.add(ID85);
3228
3229                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:350:10: ( ( LPAREN )=> LPAREN parameter ( ',' parameter )* RPAREN )?
3230                         int alt31=2;
3231                         int LA31_0 = input.LA(1);
3232                         if ( (LA31_0==LPAREN) ) {
3233                                 int LA31_1 = input.LA(2);
3234                                 if ( (synpred2_Graph()) ) {
3235                                         alt31=1;
3236                                 }
3237                         }
3238                         switch (alt31) {
3239                                 case 1 :
3240                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:350:11: ( LPAREN )=> LPAREN parameter ( ',' parameter )* RPAREN
3241                                         {
3242                                         LPAREN86=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_typeReference2358); if (state.failed) return retval;
3243                                         if ( state.backtracking==0 ) stream_LPAREN.add(LPAREN86);
3244
3245                                         pushFollow(FOLLOW_parameter_in_typeReference2360);
3246                                         parameter87=parameter();
3247                                         state._fsp--;
3248                                         if (state.failed) return retval;
3249                                         if ( state.backtracking==0 ) stream_parameter.add(parameter87.getTree());
3250                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:350:39: ( ',' parameter )*
3251                                         loop30:
3252                                         while (true) {
3253                                                 int alt30=2;
3254                                                 int LA30_0 = input.LA(1);
3255                                                 if ( (LA30_0==67) ) {
3256                                                         alt30=1;
3257                                                 }
3258
3259                                                 switch (alt30) {
3260                                                 case 1 :
3261                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:350:40: ',' parameter
3262                                                         {
3263                                                         char_literal88=(Token)match(input,67,FOLLOW_67_in_typeReference2363); if (state.failed) return retval;
3264                                                         if ( state.backtracking==0 ) stream_67.add(char_literal88);
3265
3266                                                         pushFollow(FOLLOW_parameter_in_typeReference2365);
3267                                                         parameter89=parameter();
3268                                                         state._fsp--;
3269                                                         if (state.failed) return retval;
3270                                                         if ( state.backtracking==0 ) stream_parameter.add(parameter89.getTree());
3271                                                         }
3272                                                         break;
3273
3274                                                 default :
3275                                                         break loop30;
3276                                                 }
3277                                         }
3278
3279                                         RPAREN90=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_typeReference2369); if (state.failed) return retval;
3280                                         if ( state.backtracking==0 ) stream_RPAREN.add(RPAREN90);
3281
3282                                         }
3283                                         break;
3284
3285                         }
3286
3287                         // AST REWRITE
3288                         // elements: parameter, ID
3289                         // token labels:
3290                         // rule labels: retval
3291                         // token list labels:
3292                         // rule list labels:
3293                         // wildcard labels:
3294                         if ( state.backtracking==0 ) {
3295                         retval.tree = root_0;
3296                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
3297
3298                         root_0 = (CommonTree)adaptor.nil();
3299                         // 351:5: -> ^( TYPE_REFERENCE ID ( parameter )* )
3300                         {
3301                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:351:8: ^( TYPE_REFERENCE ID ( parameter )* )
3302                                 {
3303                                 CommonTree root_1 = (CommonTree)adaptor.nil();
3304                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPE_REFERENCE, "TYPE_REFERENCE"), root_1);
3305                                 adaptor.addChild(root_1, stream_ID.nextNode());
3306                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:351:28: ( parameter )*
3307                                 while ( stream_parameter.hasNext() ) {
3308                                         adaptor.addChild(root_1, stream_parameter.nextTree());
3309                                 }
3310                                 stream_parameter.reset();
3311
3312                                 adaptor.addChild(root_0, root_1);
3313                                 }
3314
3315                         }
3316
3317
3318                         retval.tree = root_0;
3319                         }
3320
3321                         }
3322
3323                         retval.stop = input.LT(-1);
3324
3325                         if ( state.backtracking==0 ) {
3326                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
3327                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3328                         }
3329                 }
3330                 catch (RecognitionException re) {
3331                         reportError(re);
3332                         recover(input,re);
3333                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
3334                 }
3335                 finally {
3336                         // do for sure before leaving
3337                 }
3338                 return retval;
3339         }
3340         // $ANTLR end "typeReference"
3341
3342
3343         public static class parameter_return extends ParserRuleReturnScope {
3344                 CommonTree tree;
3345                 @Override
3346                 public CommonTree getTree() { return tree; }
3347         };
3348
3349
3350         // $ANTLR start "parameter"
3351         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:354:1: parameter : ( ID '=' parameterValue -> ^( TYPE_ANNOTATION ID parameterValue ) | type );
3352         public final GraphParser.parameter_return parameter() throws RecognitionException {
3353                 GraphParser.parameter_return retval = new GraphParser.parameter_return();
3354                 retval.start = input.LT(1);
3355
3356                 CommonTree root_0 = null;
3357
3358                 Token ID91=null;
3359                 Token char_literal92=null;
3360                 ParserRuleReturnScope parameterValue93 =null;
3361                 ParserRuleReturnScope type94 =null;
3362
3363                 CommonTree ID91_tree=null;
3364                 CommonTree char_literal92_tree=null;
3365                 RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
3366                 RewriteRuleTokenStream stream_74=new RewriteRuleTokenStream(adaptor,"token 74");
3367                 RewriteRuleSubtreeStream stream_parameterValue=new RewriteRuleSubtreeStream(adaptor,"rule parameterValue");
3368
3369                 try {
3370                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:355:5: ( ID '=' parameterValue -> ^( TYPE_ANNOTATION ID parameterValue ) | type )
3371                         int alt32=2;
3372                         int LA32_0 = input.LA(1);
3373                         if ( (LA32_0==ID) ) {
3374                                 int LA32_1 = input.LA(2);
3375                                 if ( (LA32_1==74) ) {
3376                                         alt32=1;
3377                                 }
3378                                 else if ( (LA32_1==LBRACKET||LA32_1==LPAREN||LA32_1==RPAREN||LA32_1==67) ) {
3379                                         alt32=2;
3380                                 }
3381
3382                                 else {
3383                                         if (state.backtracking>0) {state.failed=true; return retval;}
3384                                         int nvaeMark = input.mark();
3385                                         try {
3386                                                 input.consume();
3387                                                 NoViableAltException nvae =
3388                                                         new NoViableAltException("", 32, 1, input);
3389                                                 throw nvae;
3390                                         } finally {
3391                                                 input.rewind(nvaeMark);
3392                                         }
3393                                 }
3394
3395                         }
3396                         else if ( ((LA32_0 >= LCURLY && LA32_0 <= LPAREN)||LA32_0==80) ) {
3397                                 alt32=2;
3398                         }
3399
3400                         else {
3401                                 if (state.backtracking>0) {state.failed=true; return retval;}
3402                                 NoViableAltException nvae =
3403                                         new NoViableAltException("", 32, 0, input);
3404                                 throw nvae;
3405                         }
3406
3407                         switch (alt32) {
3408                                 case 1 :
3409                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:355:7: ID '=' parameterValue
3410                                         {
3411                                         ID91=(Token)match(input,ID,FOLLOW_ID_in_parameter2405); if (state.failed) return retval;
3412                                         if ( state.backtracking==0 ) stream_ID.add(ID91);
3413
3414                                         char_literal92=(Token)match(input,74,FOLLOW_74_in_parameter2407); if (state.failed) return retval;
3415                                         if ( state.backtracking==0 ) stream_74.add(char_literal92);
3416
3417                                         pushFollow(FOLLOW_parameterValue_in_parameter2409);
3418                                         parameterValue93=parameterValue();
3419                                         state._fsp--;
3420                                         if (state.failed) return retval;
3421                                         if ( state.backtracking==0 ) stream_parameterValue.add(parameterValue93.getTree());
3422                                         // AST REWRITE
3423                                         // elements: parameterValue, ID
3424                                         // token labels:
3425                                         // rule labels: retval
3426                                         // token list labels:
3427                                         // rule list labels:
3428                                         // wildcard labels:
3429                                         if ( state.backtracking==0 ) {
3430                                         retval.tree = root_0;
3431                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
3432
3433                                         root_0 = (CommonTree)adaptor.nil();
3434                                         // 355:29: -> ^( TYPE_ANNOTATION ID parameterValue )
3435                                         {
3436                                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:355:32: ^( TYPE_ANNOTATION ID parameterValue )
3437                                                 {
3438                                                 CommonTree root_1 = (CommonTree)adaptor.nil();
3439                                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPE_ANNOTATION, "TYPE_ANNOTATION"), root_1);
3440                                                 adaptor.addChild(root_1, stream_ID.nextNode());
3441                                                 adaptor.addChild(root_1, stream_parameterValue.nextTree());
3442                                                 adaptor.addChild(root_0, root_1);
3443                                                 }
3444
3445                                         }
3446
3447
3448                                         retval.tree = root_0;
3449                                         }
3450
3451                                         }
3452                                         break;
3453                                 case 2 :
3454                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:356:7: type
3455                                         {
3456                                         root_0 = (CommonTree)adaptor.nil();
3457
3458
3459                                         pushFollow(FOLLOW_type_in_parameter2427);
3460                                         type94=type();
3461                                         state._fsp--;
3462                                         if (state.failed) return retval;
3463                                         if ( state.backtracking==0 ) adaptor.addChild(root_0, type94.getTree());
3464
3465                                         }
3466                                         break;
3467
3468                         }
3469                         retval.stop = input.LT(-1);
3470
3471                         if ( state.backtracking==0 ) {
3472                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
3473                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3474                         }
3475                 }
3476                 catch (RecognitionException re) {
3477                         reportError(re);
3478                         recover(input,re);
3479                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
3480                 }
3481                 finally {
3482                         // do for sure before leaving
3483                 }
3484                 return retval;
3485         }
3486         // $ANTLR end "parameter"
3487
3488
3489         public static class parameterValue_return extends ParserRuleReturnScope {
3490                 CommonTree tree;
3491                 @Override
3492                 public CommonTree getTree() { return tree; }
3493         };
3494
3495
3496         // $ANTLR start "parameterValue"
3497         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:359:1: parameterValue : ( string | boolean_ | number | rangePar -> ^( RANGE rangePar ) );
3498         public final GraphParser.parameterValue_return parameterValue() throws RecognitionException {
3499                 GraphParser.parameterValue_return retval = new GraphParser.parameterValue_return();
3500                 retval.start = input.LT(1);
3501
3502                 CommonTree root_0 = null;
3503
3504                 ParserRuleReturnScope string95 =null;
3505                 ParserRuleReturnScope boolean_96 =null;
3506                 ParserRuleReturnScope number97 =null;
3507                 ParserRuleReturnScope rangePar98 =null;
3508
3509                 RewriteRuleSubtreeStream stream_rangePar=new RewriteRuleSubtreeStream(adaptor,"rule rangePar");
3510
3511                 try {
3512                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:360:5: ( string | boolean_ | number | rangePar -> ^( RANGE rangePar ) )
3513                         int alt33=4;
3514                         switch ( input.LA(1) ) {
3515                         case STRING:
3516                                 {
3517                                 alt33=1;
3518                                 }
3519                                 break;
3520                         case 78:
3521                         case 79:
3522                                 {
3523                                 alt33=2;
3524                                 }
3525                                 break;
3526                         case FLOAT:
3527                         case INT:
3528                                 {
3529                                 alt33=3;
3530                                 }
3531                                 break;
3532                         case LBRACKET:
3533                         case LPAREN:
3534                                 {
3535                                 alt33=4;
3536                                 }
3537                                 break;
3538                         default:
3539                                 if (state.backtracking>0) {state.failed=true; return retval;}
3540                                 NoViableAltException nvae =
3541                                         new NoViableAltException("", 33, 0, input);
3542                                 throw nvae;
3543                         }
3544                         switch (alt33) {
3545                                 case 1 :
3546                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:360:7: string
3547                                         {
3548                                         root_0 = (CommonTree)adaptor.nil();
3549
3550
3551                                         pushFollow(FOLLOW_string_in_parameterValue2446);
3552                                         string95=string();
3553                                         state._fsp--;
3554                                         if (state.failed) return retval;
3555                                         if ( state.backtracking==0 ) adaptor.addChild(root_0, string95.getTree());
3556
3557                                         }
3558                                         break;
3559                                 case 2 :
3560                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:361:7: boolean_
3561                                         {
3562                                         root_0 = (CommonTree)adaptor.nil();
3563
3564
3565                                         pushFollow(FOLLOW_boolean__in_parameterValue2454);
3566                                         boolean_96=boolean_();
3567                                         state._fsp--;
3568                                         if (state.failed) return retval;
3569                                         if ( state.backtracking==0 ) adaptor.addChild(root_0, boolean_96.getTree());
3570
3571                                         }
3572                                         break;
3573                                 case 3 :
3574                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:362:7: number
3575                                         {
3576                                         root_0 = (CommonTree)adaptor.nil();
3577
3578
3579                                         pushFollow(FOLLOW_number_in_parameterValue2462);
3580                                         number97=number();
3581                                         state._fsp--;
3582                                         if (state.failed) return retval;
3583                                         if ( state.backtracking==0 ) adaptor.addChild(root_0, number97.getTree());
3584
3585                                         }
3586                                         break;
3587                                 case 4 :
3588                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:363:7: rangePar
3589                                         {
3590                                         pushFollow(FOLLOW_rangePar_in_parameterValue2470);
3591                                         rangePar98=rangePar();
3592                                         state._fsp--;
3593                                         if (state.failed) return retval;
3594                                         if ( state.backtracking==0 ) stream_rangePar.add(rangePar98.getTree());
3595                                         // AST REWRITE
3596                                         // elements: rangePar
3597                                         // token labels:
3598                                         // rule labels: retval
3599                                         // token list labels:
3600                                         // rule list labels:
3601                                         // wildcard labels:
3602                                         if ( state.backtracking==0 ) {
3603                                         retval.tree = root_0;
3604                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
3605
3606                                         root_0 = (CommonTree)adaptor.nil();
3607                                         // 363:16: -> ^( RANGE rangePar )
3608                                         {
3609                                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:363:19: ^( RANGE rangePar )
3610                                                 {
3611                                                 CommonTree root_1 = (CommonTree)adaptor.nil();
3612                                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(RANGE, "RANGE"), root_1);
3613                                                 adaptor.addChild(root_1, stream_rangePar.nextTree());
3614                                                 adaptor.addChild(root_0, root_1);
3615                                                 }
3616
3617                                         }
3618
3619
3620                                         retval.tree = root_0;
3621                                         }
3622
3623                                         }
3624                                         break;
3625
3626                         }
3627                         retval.stop = input.LT(-1);
3628
3629                         if ( state.backtracking==0 ) {
3630                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
3631                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3632                         }
3633                 }
3634                 catch (RecognitionException re) {
3635                         reportError(re);
3636                         recover(input,re);
3637                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
3638                 }
3639                 finally {
3640                         // do for sure before leaving
3641                 }
3642                 return retval;
3643         }
3644         // $ANTLR end "parameterValue"
3645
3646
3647         public static class rangePar_return extends ParserRuleReturnScope {
3648                 CommonTree tree;
3649                 @Override
3650                 public CommonTree getTree() { return tree; }
3651         };
3652
3653
3654         // $ANTLR start "rangePar"
3655         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:366:1: rangePar : ( LBRACKET | LPAREN ) range ( RBRACKET | RPAREN ) ;
3656         public final GraphParser.rangePar_return rangePar() throws RecognitionException {
3657                 GraphParser.rangePar_return retval = new GraphParser.rangePar_return();
3658                 retval.start = input.LT(1);
3659
3660                 CommonTree root_0 = null;
3661
3662                 Token set99=null;
3663                 Token set101=null;
3664                 ParserRuleReturnScope range100 =null;
3665
3666                 CommonTree set99_tree=null;
3667                 CommonTree set101_tree=null;
3668
3669                 try {
3670                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:366:10: ( ( LBRACKET | LPAREN ) range ( RBRACKET | RPAREN ) )
3671                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:366:12: ( LBRACKET | LPAREN ) range ( RBRACKET | RPAREN )
3672                         {
3673                         root_0 = (CommonTree)adaptor.nil();
3674
3675
3676                         set99=input.LT(1);
3677                         if ( input.LA(1)==LBRACKET||input.LA(1)==LPAREN ) {
3678                                 input.consume();
3679                                 if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set99));
3680                                 state.errorRecovery=false;
3681                                 state.failed=false;
3682                         }
3683                         else {
3684                                 if (state.backtracking>0) {state.failed=true; return retval;}
3685                                 MismatchedSetException mse = new MismatchedSetException(null,input);
3686                                 throw mse;
3687                         }
3688                         pushFollow(FOLLOW_range_in_rangePar2507);
3689                         range100=range();
3690                         state._fsp--;
3691                         if (state.failed) return retval;
3692                         if ( state.backtracking==0 ) adaptor.addChild(root_0, range100.getTree());
3693
3694                         set101=input.LT(1);
3695                         if ( input.LA(1)==RBRACKET||input.LA(1)==RPAREN ) {
3696                                 input.consume();
3697                                 if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set101));
3698                                 state.errorRecovery=false;
3699                                 state.failed=false;
3700                         }
3701                         else {
3702                                 if (state.backtracking>0) {state.failed=true; return retval;}
3703                                 MismatchedSetException mse = new MismatchedSetException(null,input);
3704                                 throw mse;
3705                         }
3706                         }
3707
3708                         retval.stop = input.LT(-1);
3709
3710                         if ( state.backtracking==0 ) {
3711                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
3712                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3713                         }
3714                 }
3715                 catch (RecognitionException re) {
3716                         reportError(re);
3717                         recover(input,re);
3718                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
3719                 }
3720                 finally {
3721                         // do for sure before leaving
3722                 }
3723                 return retval;
3724         }
3725         // $ANTLR end "rangePar"
3726
3727
3728         public static class range_return extends ParserRuleReturnScope {
3729                 CommonTree tree;
3730                 @Override
3731                 public CommonTree getTree() { return tree; }
3732         };
3733
3734
3735         // $ANTLR start "range"
3736         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:368:1: range : ( number | RANGE | INT_RANGE );
3737         public final GraphParser.range_return range() throws RecognitionException {
3738                 GraphParser.range_return retval = new GraphParser.range_return();
3739                 retval.start = input.LT(1);
3740
3741                 CommonTree root_0 = null;
3742
3743                 Token RANGE103=null;
3744                 Token INT_RANGE104=null;
3745                 ParserRuleReturnScope number102 =null;
3746
3747                 CommonTree RANGE103_tree=null;
3748                 CommonTree INT_RANGE104_tree=null;
3749
3750                 try {
3751                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:369:5: ( number | RANGE | INT_RANGE )
3752                         int alt34=3;
3753                         switch ( input.LA(1) ) {
3754                         case FLOAT:
3755                         case INT:
3756                                 {
3757                                 alt34=1;
3758                                 }
3759                                 break;
3760                         case RANGE:
3761                                 {
3762                                 alt34=2;
3763                                 }
3764                                 break;
3765                         case INT_RANGE:
3766                                 {
3767                                 alt34=3;
3768                                 }
3769                                 break;
3770                         default:
3771                                 if (state.backtracking>0) {state.failed=true; return retval;}
3772                                 NoViableAltException nvae =
3773                                         new NoViableAltException("", 34, 0, input);
3774                                 throw nvae;
3775                         }
3776                         switch (alt34) {
3777                                 case 1 :
3778                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:369:7: number
3779                                         {
3780                                         root_0 = (CommonTree)adaptor.nil();
3781
3782
3783                                         pushFollow(FOLLOW_number_in_range2536);
3784                                         number102=number();
3785                                         state._fsp--;
3786                                         if (state.failed) return retval;
3787                                         if ( state.backtracking==0 ) adaptor.addChild(root_0, number102.getTree());
3788
3789                                         }
3790                                         break;
3791                                 case 2 :
3792                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:370:7: RANGE
3793                                         {
3794                                         root_0 = (CommonTree)adaptor.nil();
3795
3796
3797                                         RANGE103=(Token)match(input,RANGE,FOLLOW_RANGE_in_range2544); if (state.failed) return retval;
3798                                         if ( state.backtracking==0 ) {
3799                                         RANGE103_tree = (CommonTree)adaptor.create(RANGE103);
3800                                         adaptor.addChild(root_0, RANGE103_tree);
3801                                         }
3802
3803                                         }
3804                                         break;
3805                                 case 3 :
3806                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:371:7: INT_RANGE
3807                                         {
3808                                         root_0 = (CommonTree)adaptor.nil();
3809
3810
3811                                         INT_RANGE104=(Token)match(input,INT_RANGE,FOLLOW_INT_RANGE_in_range2552); if (state.failed) return retval;
3812                                         if ( state.backtracking==0 ) {
3813                                         INT_RANGE104_tree = (CommonTree)adaptor.create(INT_RANGE104);
3814                                         adaptor.addChild(root_0, INT_RANGE104_tree);
3815                                         }
3816
3817                                         }
3818                                         break;
3819
3820                         }
3821                         retval.stop = input.LT(-1);
3822
3823                         if ( state.backtracking==0 ) {
3824                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
3825                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3826                         }
3827                 }
3828                 catch (RecognitionException re) {
3829                         reportError(re);
3830                         recover(input,re);
3831                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
3832                 }
3833                 finally {
3834                         // do for sure before leaving
3835                 }
3836                 return retval;
3837         }
3838         // $ANTLR end "range"
3839
3840
3841         public static class number_return extends ParserRuleReturnScope {
3842                 CommonTree tree;
3843                 @Override
3844                 public CommonTree getTree() { return tree; }
3845         };
3846
3847
3848         // $ANTLR start "number"
3849         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:374:1: number : ( INT | FLOAT );
3850         public final GraphParser.number_return number() throws RecognitionException {
3851                 GraphParser.number_return retval = new GraphParser.number_return();
3852                 retval.start = input.LT(1);
3853
3854                 CommonTree root_0 = null;
3855
3856                 Token set105=null;
3857
3858                 CommonTree set105_tree=null;
3859
3860                 try {
3861                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:375:5: ( INT | FLOAT )
3862                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:
3863                         {
3864                         root_0 = (CommonTree)adaptor.nil();
3865
3866
3867                         set105=input.LT(1);
3868                         if ( input.LA(1)==FLOAT||input.LA(1)==INT ) {
3869                                 input.consume();
3870                                 if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set105));
3871                                 state.errorRecovery=false;
3872                                 state.failed=false;
3873                         }
3874                         else {
3875                                 if (state.backtracking>0) {state.failed=true; return retval;}
3876                                 MismatchedSetException mse = new MismatchedSetException(null,input);
3877                                 throw mse;
3878                         }
3879                         }
3880
3881                         retval.stop = input.LT(-1);
3882
3883                         if ( state.backtracking==0 ) {
3884                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
3885                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3886                         }
3887                 }
3888                 catch (RecognitionException re) {
3889                         reportError(re);
3890                         recover(input,re);
3891                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
3892                 }
3893                 finally {
3894                         // do for sure before leaving
3895                 }
3896                 return retval;
3897         }
3898         // $ANTLR end "number"
3899
3900
3901         public static class string_return extends ParserRuleReturnScope {
3902                 CommonTree tree;
3903                 @Override
3904                 public CommonTree getTree() { return tree; }
3905         };
3906
3907
3908         // $ANTLR start "string"
3909         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:379:1: string : STRING ;
3910         public final GraphParser.string_return string() throws RecognitionException {
3911                 GraphParser.string_return retval = new GraphParser.string_return();
3912                 retval.start = input.LT(1);
3913
3914                 CommonTree root_0 = null;
3915
3916                 Token STRING106=null;
3917
3918                 CommonTree STRING106_tree=null;
3919
3920                 try {
3921                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:380:5: ( STRING )
3922                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:380:7: STRING
3923                         {
3924                         root_0 = (CommonTree)adaptor.nil();
3925
3926
3927                         STRING106=(Token)match(input,STRING,FOLLOW_STRING_in_string2606); if (state.failed) return retval;
3928                         if ( state.backtracking==0 ) {
3929                         STRING106_tree = (CommonTree)adaptor.create(STRING106);
3930                         adaptor.addChild(root_0, STRING106_tree);
3931                         }
3932
3933                         }
3934
3935                         retval.stop = input.LT(-1);
3936
3937                         if ( state.backtracking==0 ) {
3938                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
3939                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3940                         }
3941                 }
3942                 catch (RecognitionException re) {
3943                         reportError(re);
3944                         recover(input,re);
3945                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
3946                 }
3947                 finally {
3948                         // do for sure before leaving
3949                 }
3950                 return retval;
3951         }
3952         // $ANTLR end "string"
3953
3954
3955         public static class boolean__return extends ParserRuleReturnScope {
3956                 CommonTree tree;
3957                 @Override
3958                 public CommonTree getTree() { return tree; }
3959         };
3960
3961
3962         // $ANTLR start "boolean_"
3963         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:383:1: boolean_ : ( 'true' -> TRUE | 'false' -> FALSE );
3964         public final GraphParser.boolean__return boolean_() throws RecognitionException {
3965                 GraphParser.boolean__return retval = new GraphParser.boolean__return();
3966                 retval.start = input.LT(1);
3967
3968                 CommonTree root_0 = null;
3969
3970                 Token string_literal107=null;
3971                 Token string_literal108=null;
3972
3973                 CommonTree string_literal107_tree=null;
3974                 CommonTree string_literal108_tree=null;
3975                 RewriteRuleTokenStream stream_78=new RewriteRuleTokenStream(adaptor,"token 78");
3976                 RewriteRuleTokenStream stream_79=new RewriteRuleTokenStream(adaptor,"token 79");
3977
3978                 try {
3979                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:384:5: ( 'true' -> TRUE | 'false' -> FALSE )
3980                         int alt35=2;
3981                         int LA35_0 = input.LA(1);
3982                         if ( (LA35_0==79) ) {
3983                                 alt35=1;
3984                         }
3985                         else if ( (LA35_0==78) ) {
3986                                 alt35=2;
3987                         }
3988
3989                         else {
3990                                 if (state.backtracking>0) {state.failed=true; return retval;}
3991                                 NoViableAltException nvae =
3992                                         new NoViableAltException("", 35, 0, input);
3993                                 throw nvae;
3994                         }
3995
3996                         switch (alt35) {
3997                                 case 1 :
3998                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:384:7: 'true'
3999                                         {
4000                                         string_literal107=(Token)match(input,79,FOLLOW_79_in_boolean_2627); if (state.failed) return retval;
4001                                         if ( state.backtracking==0 ) stream_79.add(string_literal107);
4002
4003                                         // AST REWRITE
4004                                         // elements:
4005                                         // token labels:
4006                                         // rule labels: retval
4007                                         // token list labels:
4008                                         // rule list labels:
4009                                         // wildcard labels:
4010                                         if ( state.backtracking==0 ) {
4011                                         retval.tree = root_0;
4012                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
4013
4014                                         root_0 = (CommonTree)adaptor.nil();
4015                                         // 384:14: -> TRUE
4016                                         {
4017                                                 adaptor.addChild(root_0, (CommonTree)adaptor.create(TRUE, "TRUE"));
4018                                         }
4019
4020
4021                                         retval.tree = root_0;
4022                                         }
4023
4024                                         }
4025                                         break;
4026                                 case 2 :
4027                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:385:7: 'false'
4028                                         {
4029                                         string_literal108=(Token)match(input,78,FOLLOW_78_in_boolean_2639); if (state.failed) return retval;
4030                                         if ( state.backtracking==0 ) stream_78.add(string_literal108);
4031
4032                                         // AST REWRITE
4033                                         // elements:
4034                                         // token labels:
4035                                         // rule labels: retval
4036                                         // token list labels:
4037                                         // rule list labels:
4038                                         // wildcard labels:
4039                                         if ( state.backtracking==0 ) {
4040                                         retval.tree = root_0;
4041                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
4042
4043                                         root_0 = (CommonTree)adaptor.nil();
4044                                         // 385:15: -> FALSE
4045                                         {
4046                                                 adaptor.addChild(root_0, (CommonTree)adaptor.create(FALSE, "FALSE"));
4047                                         }
4048
4049
4050                                         retval.tree = root_0;
4051                                         }
4052
4053                                         }
4054                                         break;
4055
4056                         }
4057                         retval.stop = input.LT(-1);
4058
4059                         if ( state.backtracking==0 ) {
4060                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
4061                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4062                         }
4063                 }
4064                 catch (RecognitionException re) {
4065                         reportError(re);
4066                         recover(input,re);
4067                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
4068                 }
4069                 finally {
4070                         // do for sure before leaving
4071                 }
4072                 return retval;
4073         }
4074         // $ANTLR end "boolean_"
4075
4076
4077         public static class valueDefinitions_return extends ParserRuleReturnScope {
4078                 CommonTree tree;
4079                 @Override
4080                 public CommonTree getTree() { return tree; }
4081         };
4082
4083
4084         // $ANTLR start "valueDefinitions"
4085         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:392:1: valueDefinitions : ( valueDefinition )* -> ^( VALUE_DEFINITIONS ( valueDefinition )* ) ;
4086         public final GraphParser.valueDefinitions_return valueDefinitions() throws RecognitionException {
4087                 GraphParser.valueDefinitions_return retval = new GraphParser.valueDefinitions_return();
4088                 retval.start = input.LT(1);
4089
4090                 CommonTree root_0 = null;
4091
4092                 ParserRuleReturnScope valueDefinition109 =null;
4093
4094                 RewriteRuleSubtreeStream stream_valueDefinition=new RewriteRuleSubtreeStream(adaptor,"rule valueDefinition");
4095
4096                 try {
4097                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:392:18: ( ( valueDefinition )* -> ^( VALUE_DEFINITIONS ( valueDefinition )* ) )
4098                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:392:20: ( valueDefinition )*
4099                         {
4100                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:392:20: ( valueDefinition )*
4101                         loop36:
4102                         while (true) {
4103                                 int alt36=2;
4104                                 int LA36_0 = input.LA(1);
4105                                 if ( (LA36_0==ID) ) {
4106                                         alt36=1;
4107                                 }
4108
4109                                 switch (alt36) {
4110                                 case 1 :
4111                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:392:20: valueDefinition
4112                                         {
4113                                         pushFollow(FOLLOW_valueDefinition_in_valueDefinitions2660);
4114                                         valueDefinition109=valueDefinition();
4115                                         state._fsp--;
4116                                         if (state.failed) return retval;
4117                                         if ( state.backtracking==0 ) stream_valueDefinition.add(valueDefinition109.getTree());
4118                                         }
4119                                         break;
4120
4121                                 default :
4122                                         break loop36;
4123                                 }
4124                         }
4125
4126                         // AST REWRITE
4127                         // elements: valueDefinition
4128                         // token labels:
4129                         // rule labels: retval
4130                         // token list labels:
4131                         // rule list labels:
4132                         // wildcard labels:
4133                         if ( state.backtracking==0 ) {
4134                         retval.tree = root_0;
4135                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
4136
4137                         root_0 = (CommonTree)adaptor.nil();
4138                         // 392:37: -> ^( VALUE_DEFINITIONS ( valueDefinition )* )
4139                         {
4140                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:392:40: ^( VALUE_DEFINITIONS ( valueDefinition )* )
4141                                 {
4142                                 CommonTree root_1 = (CommonTree)adaptor.nil();
4143                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(VALUE_DEFINITIONS, "VALUE_DEFINITIONS"), root_1);
4144                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:392:60: ( valueDefinition )*
4145                                 while ( stream_valueDefinition.hasNext() ) {
4146                                         adaptor.addChild(root_1, stream_valueDefinition.nextTree());
4147                                 }
4148                                 stream_valueDefinition.reset();
4149
4150                                 adaptor.addChild(root_0, root_1);
4151                                 }
4152
4153                         }
4154
4155
4156                         retval.tree = root_0;
4157                         }
4158
4159                         }
4160
4161                         retval.stop = input.LT(-1);
4162
4163                         if ( state.backtracking==0 ) {
4164                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
4165                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4166                         }
4167                 }
4168                 catch (RecognitionException re) {
4169                         reportError(re);
4170                         recover(input,re);
4171                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
4172                 }
4173                 finally {
4174                         // do for sure before leaving
4175                 }
4176                 return retval;
4177         }
4178         // $ANTLR end "valueDefinitions"
4179
4180
4181         public static class valueDefinition_return extends ParserRuleReturnScope {
4182                 CommonTree tree;
4183                 @Override
4184                 public CommonTree getTree() { return tree; }
4185         };
4186
4187
4188         // $ANTLR start "valueDefinition"
4189         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:394:1: valueDefinition : ID ':' type '=' value -> ^( VALUE_DEFINITION ID type value ) ;
4190         public final GraphParser.valueDefinition_return valueDefinition() throws RecognitionException {
4191                 GraphParser.valueDefinition_return retval = new GraphParser.valueDefinition_return();
4192                 retval.start = input.LT(1);
4193
4194                 CommonTree root_0 = null;
4195
4196                 Token ID110=null;
4197                 Token char_literal111=null;
4198                 Token char_literal113=null;
4199                 ParserRuleReturnScope type112 =null;
4200                 ParserRuleReturnScope value114 =null;
4201
4202                 CommonTree ID110_tree=null;
4203                 CommonTree char_literal111_tree=null;
4204                 CommonTree char_literal113_tree=null;
4205                 RewriteRuleTokenStream stream_70=new RewriteRuleTokenStream(adaptor,"token 70");
4206                 RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
4207                 RewriteRuleTokenStream stream_74=new RewriteRuleTokenStream(adaptor,"token 74");
4208                 RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
4209                 RewriteRuleSubtreeStream stream_value=new RewriteRuleSubtreeStream(adaptor,"rule value");
4210
4211                 try {
4212                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:395:5: ( ID ':' type '=' value -> ^( VALUE_DEFINITION ID type value ) )
4213                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:395:7: ID ':' type '=' value
4214                         {
4215                         ID110=(Token)match(input,ID,FOLLOW_ID_in_valueDefinition2683); if (state.failed) return retval;
4216                         if ( state.backtracking==0 ) stream_ID.add(ID110);
4217
4218                         char_literal111=(Token)match(input,70,FOLLOW_70_in_valueDefinition2685); if (state.failed) return retval;
4219                         if ( state.backtracking==0 ) stream_70.add(char_literal111);
4220
4221                         pushFollow(FOLLOW_type_in_valueDefinition2687);
4222                         type112=type();
4223                         state._fsp--;
4224                         if (state.failed) return retval;
4225                         if ( state.backtracking==0 ) stream_type.add(type112.getTree());
4226                         char_literal113=(Token)match(input,74,FOLLOW_74_in_valueDefinition2689); if (state.failed) return retval;
4227                         if ( state.backtracking==0 ) stream_74.add(char_literal113);
4228
4229                         pushFollow(FOLLOW_value_in_valueDefinition2691);
4230                         value114=value();
4231                         state._fsp--;
4232                         if (state.failed) return retval;
4233                         if ( state.backtracking==0 ) stream_value.add(value114.getTree());
4234                         // AST REWRITE
4235                         // elements: ID, value, type
4236                         // token labels:
4237                         // rule labels: retval
4238                         // token list labels:
4239                         // rule list labels:
4240                         // wildcard labels:
4241                         if ( state.backtracking==0 ) {
4242                         retval.tree = root_0;
4243                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
4244
4245                         root_0 = (CommonTree)adaptor.nil();
4246                         // 396:5: -> ^( VALUE_DEFINITION ID type value )
4247                         {
4248                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:396:8: ^( VALUE_DEFINITION ID type value )
4249                                 {
4250                                 CommonTree root_1 = (CommonTree)adaptor.nil();
4251                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(VALUE_DEFINITION, "VALUE_DEFINITION"), root_1);
4252                                 adaptor.addChild(root_1, stream_ID.nextNode());
4253                                 adaptor.addChild(root_1, stream_type.nextTree());
4254                                 adaptor.addChild(root_1, stream_value.nextTree());
4255                                 adaptor.addChild(root_0, root_1);
4256                                 }
4257
4258                         }
4259
4260
4261                         retval.tree = root_0;
4262                         }
4263
4264                         }
4265
4266                         retval.stop = input.LT(-1);
4267
4268                         if ( state.backtracking==0 ) {
4269                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
4270                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4271                         }
4272                 }
4273                 catch (RecognitionException re) {
4274                         reportError(re);
4275                         recover(input,re);
4276                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
4277                 }
4278                 finally {
4279                         // do for sure before leaving
4280                 }
4281                 return retval;
4282         }
4283         // $ANTLR end "valueDefinition"
4284
4285
4286         public static class value_return extends ParserRuleReturnScope {
4287                 CommonTree tree;
4288                 @Override
4289                 public CommonTree getTree() { return tree; }
4290         };
4291
4292
4293         // $ANTLR start "value"
4294         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:399:1: value : ( basicValue -> basicValue ) ( ':' type -> ^( VARIANT type $value) )* ;
4295         public final GraphParser.value_return value() throws RecognitionException {
4296                 GraphParser.value_return retval = new GraphParser.value_return();
4297                 retval.start = input.LT(1);
4298
4299                 CommonTree root_0 = null;
4300
4301                 Token char_literal116=null;
4302                 ParserRuleReturnScope basicValue115 =null;
4303                 ParserRuleReturnScope type117 =null;
4304
4305                 CommonTree char_literal116_tree=null;
4306                 RewriteRuleTokenStream stream_70=new RewriteRuleTokenStream(adaptor,"token 70");
4307                 RewriteRuleSubtreeStream stream_basicValue=new RewriteRuleSubtreeStream(adaptor,"rule basicValue");
4308                 RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
4309
4310                 try {
4311                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:400:5: ( ( basicValue -> basicValue ) ( ':' type -> ^( VARIANT type $value) )* )
4312                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:400:7: ( basicValue -> basicValue ) ( ':' type -> ^( VARIANT type $value) )*
4313                         {
4314                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:400:7: ( basicValue -> basicValue )
4315                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:400:8: basicValue
4316                         {
4317                         pushFollow(FOLLOW_basicValue_in_value2727);
4318                         basicValue115=basicValue();
4319                         state._fsp--;
4320                         if (state.failed) return retval;
4321                         if ( state.backtracking==0 ) stream_basicValue.add(basicValue115.getTree());
4322                         // AST REWRITE
4323                         // elements: basicValue
4324                         // token labels:
4325                         // rule labels: retval
4326                         // token list labels:
4327                         // rule list labels:
4328                         // wildcard labels:
4329                         if ( state.backtracking==0 ) {
4330                         retval.tree = root_0;
4331                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
4332
4333                         root_0 = (CommonTree)adaptor.nil();
4334                         // 400:19: -> basicValue
4335                         {
4336                                 adaptor.addChild(root_0, stream_basicValue.nextTree());
4337                         }
4338
4339
4340                         retval.tree = root_0;
4341                         }
4342
4343                         }
4344
4345                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:401:7: ( ':' type -> ^( VARIANT type $value) )*
4346                         loop37:
4347                         while (true) {
4348                                 int alt37=2;
4349                                 int LA37_0 = input.LA(1);
4350                                 if ( (LA37_0==70) ) {
4351                                         alt37=1;
4352                                 }
4353
4354                                 switch (alt37) {
4355                                 case 1 :
4356                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:401:8: ':' type
4357                                         {
4358                                         char_literal116=(Token)match(input,70,FOLLOW_70_in_value2741); if (state.failed) return retval;
4359                                         if ( state.backtracking==0 ) stream_70.add(char_literal116);
4360
4361                                         pushFollow(FOLLOW_type_in_value2743);
4362                                         type117=type();
4363                                         state._fsp--;
4364                                         if (state.failed) return retval;
4365                                         if ( state.backtracking==0 ) stream_type.add(type117.getTree());
4366                                         // AST REWRITE
4367                                         // elements: type, value
4368                                         // token labels:
4369                                         // rule labels: retval
4370                                         // token list labels:
4371                                         // rule list labels:
4372                                         // wildcard labels:
4373                                         if ( state.backtracking==0 ) {
4374                                         retval.tree = root_0;
4375                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
4376
4377                                         root_0 = (CommonTree)adaptor.nil();
4378                                         // 401:17: -> ^( VARIANT type $value)
4379                                         {
4380                                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:401:20: ^( VARIANT type $value)
4381                                                 {
4382                                                 CommonTree root_1 = (CommonTree)adaptor.nil();
4383                                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(VARIANT, "VARIANT"), root_1);
4384                                                 adaptor.addChild(root_1, stream_type.nextTree());
4385                                                 adaptor.addChild(root_1, stream_retval.nextTree());
4386                                                 adaptor.addChild(root_0, root_1);
4387                                                 }
4388
4389                                         }
4390
4391
4392                                         retval.tree = root_0;
4393                                         }
4394
4395                                         }
4396                                         break;
4397
4398                                 default :
4399                                         break loop37;
4400                                 }
4401                         }
4402
4403                         }
4404
4405                         retval.stop = input.LT(-1);
4406
4407                         if ( state.backtracking==0 ) {
4408                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
4409                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4410                         }
4411                 }
4412                 catch (RecognitionException re) {
4413                         reportError(re);
4414                         recover(input,re);
4415                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
4416                 }
4417                 finally {
4418                         // do for sure before leaving
4419                 }
4420                 return retval;
4421         }
4422         // $ANTLR end "value"
4423
4424
4425         public static class basicValue_return extends ParserRuleReturnScope {
4426                 CommonTree tree;
4427                 @Override
4428                 public CommonTree getTree() { return tree; }
4429         };
4430
4431
4432         // $ANTLR start "basicValue"
4433         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:404:1: basicValue : ( simpleValue | map |{...}? ID -> NO_VALUE | taggedValue );
4434         public final GraphParser.basicValue_return basicValue() throws RecognitionException {
4435                 GraphParser.basicValue_return retval = new GraphParser.basicValue_return();
4436                 retval.start = input.LT(1);
4437
4438                 CommonTree root_0 = null;
4439
4440                 Token ID120=null;
4441                 ParserRuleReturnScope simpleValue118 =null;
4442                 ParserRuleReturnScope map119 =null;
4443                 ParserRuleReturnScope taggedValue121 =null;
4444
4445                 CommonTree ID120_tree=null;
4446                 RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
4447
4448                 try {
4449                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:405:5: ( simpleValue | map |{...}? ID -> NO_VALUE | taggedValue )
4450                         int alt38=4;
4451                         int LA38_0 = input.LA(1);
4452                         if ( (LA38_0==FLOAT||LA38_0==INT||(LA38_0 >= LBRACKET && LA38_0 <= LPAREN)||LA38_0==STRING||(LA38_0 >= 78 && LA38_0 <= 79)) ) {
4453                                 alt38=1;
4454                         }
4455                         else if ( (LA38_0==ID) ) {
4456                                 int LA38_2 = input.LA(2);
4457                                 if ( (LA38_2==LCURLY) && ((input.LT(1).getText().equals("map")))) {
4458                                         alt38=2;
4459                                 }
4460                                 else if ( ((input.LT(1).getText().equals("null"))) ) {
4461                                         alt38=3;
4462                                 }
4463                                 else if ( (true) ) {
4464                                         alt38=4;
4465                                 }
4466
4467                         }
4468
4469                         else {
4470                                 if (state.backtracking>0) {state.failed=true; return retval;}
4471                                 NoViableAltException nvae =
4472                                         new NoViableAltException("", 38, 0, input);
4473                                 throw nvae;
4474                         }
4475
4476                         switch (alt38) {
4477                                 case 1 :
4478                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:405:7: simpleValue
4479                                         {
4480                                         root_0 = (CommonTree)adaptor.nil();
4481
4482
4483                                         pushFollow(FOLLOW_simpleValue_in_basicValue2775);
4484                                         simpleValue118=simpleValue();
4485                                         state._fsp--;
4486                                         if (state.failed) return retval;
4487                                         if ( state.backtracking==0 ) adaptor.addChild(root_0, simpleValue118.getTree());
4488
4489                                         }
4490                                         break;
4491                                 case 2 :
4492                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:406:7: map
4493                                         {
4494                                         root_0 = (CommonTree)adaptor.nil();
4495
4496
4497                                         pushFollow(FOLLOW_map_in_basicValue2783);
4498                                         map119=map();
4499                                         state._fsp--;
4500                                         if (state.failed) return retval;
4501                                         if ( state.backtracking==0 ) adaptor.addChild(root_0, map119.getTree());
4502
4503                                         }
4504                                         break;
4505                                 case 3 :
4506                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:407:7: {...}? ID
4507                                         {
4508                                         if ( !((input.LT(1).getText().equals("null"))) ) {
4509                                                 if (state.backtracking>0) {state.failed=true; return retval;}
4510                                                 throw new FailedPredicateException(input, "basicValue", "input.LT(1).getText().equals(\"null\")");
4511                                         }
4512                                         ID120=(Token)match(input,ID,FOLLOW_ID_in_basicValue2793); if (state.failed) return retval;
4513                                         if ( state.backtracking==0 ) stream_ID.add(ID120);
4514
4515                                         // AST REWRITE
4516                                         // elements:
4517                                         // token labels:
4518                                         // rule labels: retval
4519                                         // token list labels:
4520                                         // rule list labels:
4521                                         // wildcard labels:
4522                                         if ( state.backtracking==0 ) {
4523                                         retval.tree = root_0;
4524                                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
4525
4526                                         root_0 = (CommonTree)adaptor.nil();
4527                                         // 407:50: -> NO_VALUE
4528                                         {
4529                                                 adaptor.addChild(root_0, (CommonTree)adaptor.create(NO_VALUE, "NO_VALUE"));
4530                                         }
4531
4532
4533                                         retval.tree = root_0;
4534                                         }
4535
4536                                         }
4537                                         break;
4538                                 case 4 :
4539                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:408:7: taggedValue
4540                                         {
4541                                         root_0 = (CommonTree)adaptor.nil();
4542
4543
4544                                         pushFollow(FOLLOW_taggedValue_in_basicValue2805);
4545                                         taggedValue121=taggedValue();
4546                                         state._fsp--;
4547                                         if (state.failed) return retval;
4548                                         if ( state.backtracking==0 ) adaptor.addChild(root_0, taggedValue121.getTree());
4549
4550                                         }
4551                                         break;
4552
4553                         }
4554                         retval.stop = input.LT(-1);
4555
4556                         if ( state.backtracking==0 ) {
4557                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
4558                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4559                         }
4560                 }
4561                 catch (RecognitionException re) {
4562                         reportError(re);
4563                         recover(input,re);
4564                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
4565                 }
4566                 finally {
4567                         // do for sure before leaving
4568                 }
4569                 return retval;
4570         }
4571         // $ANTLR end "basicValue"
4572
4573
4574         public static class simpleValue_return extends ParserRuleReturnScope {
4575                 CommonTree tree;
4576                 @Override
4577                 public CommonTree getTree() { return tree; }
4578         };
4579
4580
4581         // $ANTLR start "simpleValue"
4582         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:411:1: simpleValue : ( string | number | boolean_ | array | tuple | record );
4583         public final GraphParser.simpleValue_return simpleValue() throws RecognitionException {
4584                 GraphParser.simpleValue_return retval = new GraphParser.simpleValue_return();
4585                 retval.start = input.LT(1);
4586
4587                 CommonTree root_0 = null;
4588
4589                 ParserRuleReturnScope string122 =null;
4590                 ParserRuleReturnScope number123 =null;
4591                 ParserRuleReturnScope boolean_124 =null;
4592                 ParserRuleReturnScope array125 =null;
4593                 ParserRuleReturnScope tuple126 =null;
4594                 ParserRuleReturnScope record127 =null;
4595
4596
4597                 try {
4598                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:412:5: ( string | number | boolean_ | array | tuple | record )
4599                         int alt39=6;
4600                         switch ( input.LA(1) ) {
4601                         case STRING:
4602                                 {
4603                                 alt39=1;
4604                                 }
4605                                 break;
4606                         case FLOAT:
4607                         case INT:
4608                                 {
4609                                 alt39=2;
4610                                 }
4611                                 break;
4612                         case 78:
4613                         case 79:
4614                                 {
4615                                 alt39=3;
4616                                 }
4617                                 break;
4618                         case LBRACKET:
4619                                 {
4620                                 alt39=4;
4621                                 }
4622                                 break;
4623                         case LPAREN:
4624                                 {
4625                                 alt39=5;
4626                                 }
4627                                 break;
4628                         case LCURLY:
4629                                 {
4630                                 alt39=6;
4631                                 }
4632                                 break;
4633                         default:
4634                                 if (state.backtracking>0) {state.failed=true; return retval;}
4635                                 NoViableAltException nvae =
4636                                         new NoViableAltException("", 39, 0, input);
4637                                 throw nvae;
4638                         }
4639                         switch (alt39) {
4640                                 case 1 :
4641                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:412:7: string
4642                                         {
4643                                         root_0 = (CommonTree)adaptor.nil();
4644
4645
4646                                         pushFollow(FOLLOW_string_in_simpleValue2830);
4647                                         string122=string();
4648                                         state._fsp--;
4649                                         if (state.failed) return retval;
4650                                         if ( state.backtracking==0 ) adaptor.addChild(root_0, string122.getTree());
4651
4652                                         }
4653                                         break;
4654                                 case 2 :
4655                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:413:7: number
4656                                         {
4657                                         root_0 = (CommonTree)adaptor.nil();
4658
4659
4660                                         pushFollow(FOLLOW_number_in_simpleValue2838);
4661                                         number123=number();
4662                                         state._fsp--;
4663                                         if (state.failed) return retval;
4664                                         if ( state.backtracking==0 ) adaptor.addChild(root_0, number123.getTree());
4665
4666                                         }
4667                                         break;
4668                                 case 3 :
4669                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:414:7: boolean_
4670                                         {
4671                                         root_0 = (CommonTree)adaptor.nil();
4672
4673
4674                                         pushFollow(FOLLOW_boolean__in_simpleValue2846);
4675                                         boolean_124=boolean_();
4676                                         state._fsp--;
4677                                         if (state.failed) return retval;
4678                                         if ( state.backtracking==0 ) adaptor.addChild(root_0, boolean_124.getTree());
4679
4680                                         }
4681                                         break;
4682                                 case 4 :
4683                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:415:7: array
4684                                         {
4685                                         root_0 = (CommonTree)adaptor.nil();
4686
4687
4688                                         pushFollow(FOLLOW_array_in_simpleValue2854);
4689                                         array125=array();
4690                                         state._fsp--;
4691                                         if (state.failed) return retval;
4692                                         if ( state.backtracking==0 ) adaptor.addChild(root_0, array125.getTree());
4693
4694                                         }
4695                                         break;
4696                                 case 5 :
4697                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:416:7: tuple
4698                                         {
4699                                         root_0 = (CommonTree)adaptor.nil();
4700
4701
4702                                         pushFollow(FOLLOW_tuple_in_simpleValue2862);
4703                                         tuple126=tuple();
4704                                         state._fsp--;
4705                                         if (state.failed) return retval;
4706                                         if ( state.backtracking==0 ) adaptor.addChild(root_0, tuple126.getTree());
4707
4708                                         }
4709                                         break;
4710                                 case 6 :
4711                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:417:7: record
4712                                         {
4713                                         root_0 = (CommonTree)adaptor.nil();
4714
4715
4716                                         pushFollow(FOLLOW_record_in_simpleValue2870);
4717                                         record127=record();
4718                                         state._fsp--;
4719                                         if (state.failed) return retval;
4720                                         if ( state.backtracking==0 ) adaptor.addChild(root_0, record127.getTree());
4721
4722                                         }
4723                                         break;
4724
4725                         }
4726                         retval.stop = input.LT(-1);
4727
4728                         if ( state.backtracking==0 ) {
4729                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
4730                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4731                         }
4732                 }
4733                 catch (RecognitionException re) {
4734                         reportError(re);
4735                         recover(input,re);
4736                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
4737                 }
4738                 finally {
4739                         // do for sure before leaving
4740                 }
4741                 return retval;
4742         }
4743         // $ANTLR end "simpleValue"
4744
4745
4746         public static class array_return extends ParserRuleReturnScope {
4747                 CommonTree tree;
4748                 @Override
4749                 public CommonTree getTree() { return tree; }
4750         };
4751
4752
4753         // $ANTLR start "array"
4754         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:420:1: array : LBRACKET ( value ( ',' value )* )? RBRACKET -> ^( ARRAY ( value )* ) ;
4755         public final GraphParser.array_return array() throws RecognitionException {
4756                 GraphParser.array_return retval = new GraphParser.array_return();
4757                 retval.start = input.LT(1);
4758
4759                 CommonTree root_0 = null;
4760
4761                 Token LBRACKET128=null;
4762                 Token char_literal130=null;
4763                 Token RBRACKET132=null;
4764                 ParserRuleReturnScope value129 =null;
4765                 ParserRuleReturnScope value131 =null;
4766
4767                 CommonTree LBRACKET128_tree=null;
4768                 CommonTree char_literal130_tree=null;
4769                 CommonTree RBRACKET132_tree=null;
4770                 RewriteRuleTokenStream stream_67=new RewriteRuleTokenStream(adaptor,"token 67");
4771                 RewriteRuleTokenStream stream_LBRACKET=new RewriteRuleTokenStream(adaptor,"token LBRACKET");
4772                 RewriteRuleTokenStream stream_RBRACKET=new RewriteRuleTokenStream(adaptor,"token RBRACKET");
4773                 RewriteRuleSubtreeStream stream_value=new RewriteRuleSubtreeStream(adaptor,"rule value");
4774
4775                 try {
4776                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:421:5: ( LBRACKET ( value ( ',' value )* )? RBRACKET -> ^( ARRAY ( value )* ) )
4777                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:421:7: LBRACKET ( value ( ',' value )* )? RBRACKET
4778                         {
4779                         LBRACKET128=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_array2891); if (state.failed) return retval;
4780                         if ( state.backtracking==0 ) stream_LBRACKET.add(LBRACKET128);
4781
4782                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:421:16: ( value ( ',' value )* )?
4783                         int alt41=2;
4784                         int LA41_0 = input.LA(1);
4785                         if ( (LA41_0==FLOAT||LA41_0==ID||LA41_0==INT||(LA41_0 >= LBRACKET && LA41_0 <= LPAREN)||LA41_0==STRING||(LA41_0 >= 78 && LA41_0 <= 79)) ) {
4786                                 alt41=1;
4787                         }
4788                         switch (alt41) {
4789                                 case 1 :
4790                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:421:17: value ( ',' value )*
4791                                         {
4792                                         pushFollow(FOLLOW_value_in_array2894);
4793                                         value129=value();
4794                                         state._fsp--;
4795                                         if (state.failed) return retval;
4796                                         if ( state.backtracking==0 ) stream_value.add(value129.getTree());
4797                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:421:23: ( ',' value )*
4798                                         loop40:
4799                                         while (true) {
4800                                                 int alt40=2;
4801                                                 int LA40_0 = input.LA(1);
4802                                                 if ( (LA40_0==67) ) {
4803                                                         alt40=1;
4804                                                 }
4805
4806                                                 switch (alt40) {
4807                                                 case 1 :
4808                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:421:24: ',' value
4809                                                         {
4810                                                         char_literal130=(Token)match(input,67,FOLLOW_67_in_array2897); if (state.failed) return retval;
4811                                                         if ( state.backtracking==0 ) stream_67.add(char_literal130);
4812
4813                                                         pushFollow(FOLLOW_value_in_array2899);
4814                                                         value131=value();
4815                                                         state._fsp--;
4816                                                         if (state.failed) return retval;
4817                                                         if ( state.backtracking==0 ) stream_value.add(value131.getTree());
4818                                                         }
4819                                                         break;
4820
4821                                                 default :
4822                                                         break loop40;
4823                                                 }
4824                                         }
4825
4826                                         }
4827                                         break;
4828
4829                         }
4830
4831                         RBRACKET132=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_array2905); if (state.failed) return retval;
4832                         if ( state.backtracking==0 ) stream_RBRACKET.add(RBRACKET132);
4833
4834                         // AST REWRITE
4835                         // elements: value
4836                         // token labels:
4837                         // rule labels: retval
4838                         // token list labels:
4839                         // rule list labels:
4840                         // wildcard labels:
4841                         if ( state.backtracking==0 ) {
4842                         retval.tree = root_0;
4843                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
4844
4845                         root_0 = (CommonTree)adaptor.nil();
4846                         // 422:5: -> ^( ARRAY ( value )* )
4847                         {
4848                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:422:8: ^( ARRAY ( value )* )
4849                                 {
4850                                 CommonTree root_1 = (CommonTree)adaptor.nil();
4851                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ARRAY, "ARRAY"), root_1);
4852                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:422:16: ( value )*
4853                                 while ( stream_value.hasNext() ) {
4854                                         adaptor.addChild(root_1, stream_value.nextTree());
4855                                 }
4856                                 stream_value.reset();
4857
4858                                 adaptor.addChild(root_0, root_1);
4859                                 }
4860
4861                         }
4862
4863
4864                         retval.tree = root_0;
4865                         }
4866
4867                         }
4868
4869                         retval.stop = input.LT(-1);
4870
4871                         if ( state.backtracking==0 ) {
4872                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
4873                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4874                         }
4875                 }
4876                 catch (RecognitionException re) {
4877                         reportError(re);
4878                         recover(input,re);
4879                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
4880                 }
4881                 finally {
4882                         // do for sure before leaving
4883                 }
4884                 return retval;
4885         }
4886         // $ANTLR end "array"
4887
4888
4889         public static class tuple_return extends ParserRuleReturnScope {
4890                 CommonTree tree;
4891                 @Override
4892                 public CommonTree getTree() { return tree; }
4893         };
4894
4895
4896         // $ANTLR start "tuple"
4897         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:425:1: tuple : LPAREN ( value ( ',' value )* )? RPAREN -> ^( TUPLE ( value )* ) ;
4898         public final GraphParser.tuple_return tuple() throws RecognitionException {
4899                 GraphParser.tuple_return retval = new GraphParser.tuple_return();
4900                 retval.start = input.LT(1);
4901
4902                 CommonTree root_0 = null;
4903
4904                 Token LPAREN133=null;
4905                 Token char_literal135=null;
4906                 Token RPAREN137=null;
4907                 ParserRuleReturnScope value134 =null;
4908                 ParserRuleReturnScope value136 =null;
4909
4910                 CommonTree LPAREN133_tree=null;
4911                 CommonTree char_literal135_tree=null;
4912                 CommonTree RPAREN137_tree=null;
4913                 RewriteRuleTokenStream stream_67=new RewriteRuleTokenStream(adaptor,"token 67");
4914                 RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
4915                 RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
4916                 RewriteRuleSubtreeStream stream_value=new RewriteRuleSubtreeStream(adaptor,"rule value");
4917
4918                 try {
4919                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:426:5: ( LPAREN ( value ( ',' value )* )? RPAREN -> ^( TUPLE ( value )* ) )
4920                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:426:7: LPAREN ( value ( ',' value )* )? RPAREN
4921                         {
4922                         LPAREN133=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_tuple2937); if (state.failed) return retval;
4923                         if ( state.backtracking==0 ) stream_LPAREN.add(LPAREN133);
4924
4925                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:426:14: ( value ( ',' value )* )?
4926                         int alt43=2;
4927                         int LA43_0 = input.LA(1);
4928                         if ( (LA43_0==FLOAT||LA43_0==ID||LA43_0==INT||(LA43_0 >= LBRACKET && LA43_0 <= LPAREN)||LA43_0==STRING||(LA43_0 >= 78 && LA43_0 <= 79)) ) {
4929                                 alt43=1;
4930                         }
4931                         switch (alt43) {
4932                                 case 1 :
4933                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:426:15: value ( ',' value )*
4934                                         {
4935                                         pushFollow(FOLLOW_value_in_tuple2940);
4936                                         value134=value();
4937                                         state._fsp--;
4938                                         if (state.failed) return retval;
4939                                         if ( state.backtracking==0 ) stream_value.add(value134.getTree());
4940                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:426:21: ( ',' value )*
4941                                         loop42:
4942                                         while (true) {
4943                                                 int alt42=2;
4944                                                 int LA42_0 = input.LA(1);
4945                                                 if ( (LA42_0==67) ) {
4946                                                         alt42=1;
4947                                                 }
4948
4949                                                 switch (alt42) {
4950                                                 case 1 :
4951                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:426:22: ',' value
4952                                                         {
4953                                                         char_literal135=(Token)match(input,67,FOLLOW_67_in_tuple2943); if (state.failed) return retval;
4954                                                         if ( state.backtracking==0 ) stream_67.add(char_literal135);
4955
4956                                                         pushFollow(FOLLOW_value_in_tuple2945);
4957                                                         value136=value();
4958                                                         state._fsp--;
4959                                                         if (state.failed) return retval;
4960                                                         if ( state.backtracking==0 ) stream_value.add(value136.getTree());
4961                                                         }
4962                                                         break;
4963
4964                                                 default :
4965                                                         break loop42;
4966                                                 }
4967                                         }
4968
4969                                         }
4970                                         break;
4971
4972                         }
4973
4974                         RPAREN137=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_tuple2951); if (state.failed) return retval;
4975                         if ( state.backtracking==0 ) stream_RPAREN.add(RPAREN137);
4976
4977                         // AST REWRITE
4978                         // elements: value
4979                         // token labels:
4980                         // rule labels: retval
4981                         // token list labels:
4982                         // rule list labels:
4983                         // wildcard labels:
4984                         if ( state.backtracking==0 ) {
4985                         retval.tree = root_0;
4986                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
4987
4988                         root_0 = (CommonTree)adaptor.nil();
4989                         // 427:5: -> ^( TUPLE ( value )* )
4990                         {
4991                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:427:8: ^( TUPLE ( value )* )
4992                                 {
4993                                 CommonTree root_1 = (CommonTree)adaptor.nil();
4994                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TUPLE, "TUPLE"), root_1);
4995                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:427:16: ( value )*
4996                                 while ( stream_value.hasNext() ) {
4997                                         adaptor.addChild(root_1, stream_value.nextTree());
4998                                 }
4999                                 stream_value.reset();
5000
5001                                 adaptor.addChild(root_0, root_1);
5002                                 }
5003
5004                         }
5005
5006
5007                         retval.tree = root_0;
5008                         }
5009
5010                         }
5011
5012                         retval.stop = input.LT(-1);
5013
5014                         if ( state.backtracking==0 ) {
5015                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
5016                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5017                         }
5018                 }
5019                 catch (RecognitionException re) {
5020                         reportError(re);
5021                         recover(input,re);
5022                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
5023                 }
5024                 finally {
5025                         // do for sure before leaving
5026                 }
5027                 return retval;
5028         }
5029         // $ANTLR end "tuple"
5030
5031
5032         public static class taggedValue_return extends ParserRuleReturnScope {
5033                 CommonTree tree;
5034                 @Override
5035                 public CommonTree getTree() { return tree; }
5036         };
5037
5038
5039         // $ANTLR start "taggedValue"
5040         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:430:1: taggedValue : ID ( simpleValue )? -> ^( TAGGED_VALUE ID ( simpleValue )? ) ;
5041         public final GraphParser.taggedValue_return taggedValue() throws RecognitionException {
5042                 GraphParser.taggedValue_return retval = new GraphParser.taggedValue_return();
5043                 retval.start = input.LT(1);
5044
5045                 CommonTree root_0 = null;
5046
5047                 Token ID138=null;
5048                 ParserRuleReturnScope simpleValue139 =null;
5049
5050                 CommonTree ID138_tree=null;
5051                 RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
5052                 RewriteRuleSubtreeStream stream_simpleValue=new RewriteRuleSubtreeStream(adaptor,"rule simpleValue");
5053
5054                 try {
5055                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:431:5: ( ID ( simpleValue )? -> ^( TAGGED_VALUE ID ( simpleValue )? ) )
5056                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:431:7: ID ( simpleValue )?
5057                         {
5058                         ID138=(Token)match(input,ID,FOLLOW_ID_in_taggedValue2983); if (state.failed) return retval;
5059                         if ( state.backtracking==0 ) stream_ID.add(ID138);
5060
5061                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:431:10: ( simpleValue )?
5062                         int alt44=2;
5063                         int LA44_0 = input.LA(1);
5064                         if ( (LA44_0==FLOAT||LA44_0==INT||(LA44_0 >= LBRACKET && LA44_0 <= LPAREN)||LA44_0==STRING||(LA44_0 >= 78 && LA44_0 <= 79)) ) {
5065                                 alt44=1;
5066                         }
5067                         switch (alt44) {
5068                                 case 1 :
5069                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:431:10: simpleValue
5070                                         {
5071                                         pushFollow(FOLLOW_simpleValue_in_taggedValue2985);
5072                                         simpleValue139=simpleValue();
5073                                         state._fsp--;
5074                                         if (state.failed) return retval;
5075                                         if ( state.backtracking==0 ) stream_simpleValue.add(simpleValue139.getTree());
5076                                         }
5077                                         break;
5078
5079                         }
5080
5081                         // AST REWRITE
5082                         // elements: ID, simpleValue
5083                         // token labels:
5084                         // rule labels: retval
5085                         // token list labels:
5086                         // rule list labels:
5087                         // wildcard labels:
5088                         if ( state.backtracking==0 ) {
5089                         retval.tree = root_0;
5090                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
5091
5092                         root_0 = (CommonTree)adaptor.nil();
5093                         // 432:5: -> ^( TAGGED_VALUE ID ( simpleValue )? )
5094                         {
5095                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:432:8: ^( TAGGED_VALUE ID ( simpleValue )? )
5096                                 {
5097                                 CommonTree root_1 = (CommonTree)adaptor.nil();
5098                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TAGGED_VALUE, "TAGGED_VALUE"), root_1);
5099                                 adaptor.addChild(root_1, stream_ID.nextNode());
5100                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:432:26: ( simpleValue )?
5101                                 if ( stream_simpleValue.hasNext() ) {
5102                                         adaptor.addChild(root_1, stream_simpleValue.nextTree());
5103                                 }
5104                                 stream_simpleValue.reset();
5105
5106                                 adaptor.addChild(root_0, root_1);
5107                                 }
5108
5109                         }
5110
5111
5112                         retval.tree = root_0;
5113                         }
5114
5115                         }
5116
5117                         retval.stop = input.LT(-1);
5118
5119                         if ( state.backtracking==0 ) {
5120                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
5121                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5122                         }
5123                 }
5124                 catch (RecognitionException re) {
5125                         reportError(re);
5126                         recover(input,re);
5127                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
5128                 }
5129                 finally {
5130                         // do for sure before leaving
5131                 }
5132                 return retval;
5133         }
5134         // $ANTLR end "taggedValue"
5135
5136
5137         public static class record_return extends ParserRuleReturnScope {
5138                 CommonTree tree;
5139                 @Override
5140                 public CommonTree getTree() { return tree; }
5141         };
5142
5143
5144         // $ANTLR start "record"
5145         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:435:1: record : LCURLY ( recordAssignment ( ',' recordAssignment )* )? RCURLY -> ^( RECORD ( recordAssignment )* ) ;
5146         public final GraphParser.record_return record() throws RecognitionException {
5147                 GraphParser.record_return retval = new GraphParser.record_return();
5148                 retval.start = input.LT(1);
5149
5150                 CommonTree root_0 = null;
5151
5152                 Token LCURLY140=null;
5153                 Token char_literal142=null;
5154                 Token RCURLY144=null;
5155                 ParserRuleReturnScope recordAssignment141 =null;
5156                 ParserRuleReturnScope recordAssignment143 =null;
5157
5158                 CommonTree LCURLY140_tree=null;
5159                 CommonTree char_literal142_tree=null;
5160                 CommonTree RCURLY144_tree=null;
5161                 RewriteRuleTokenStream stream_67=new RewriteRuleTokenStream(adaptor,"token 67");
5162                 RewriteRuleTokenStream stream_LCURLY=new RewriteRuleTokenStream(adaptor,"token LCURLY");
5163                 RewriteRuleTokenStream stream_RCURLY=new RewriteRuleTokenStream(adaptor,"token RCURLY");
5164                 RewriteRuleSubtreeStream stream_recordAssignment=new RewriteRuleSubtreeStream(adaptor,"rule recordAssignment");
5165
5166                 try {
5167                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:436:5: ( LCURLY ( recordAssignment ( ',' recordAssignment )* )? RCURLY -> ^( RECORD ( recordAssignment )* ) )
5168                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:436:7: LCURLY ( recordAssignment ( ',' recordAssignment )* )? RCURLY
5169                         {
5170                         LCURLY140=(Token)match(input,LCURLY,FOLLOW_LCURLY_in_record3020); if (state.failed) return retval;
5171                         if ( state.backtracking==0 ) stream_LCURLY.add(LCURLY140);
5172
5173                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:436:14: ( recordAssignment ( ',' recordAssignment )* )?
5174                         int alt46=2;
5175                         int LA46_0 = input.LA(1);
5176                         if ( (LA46_0==ID) ) {
5177                                 alt46=1;
5178                         }
5179                         switch (alt46) {
5180                                 case 1 :
5181                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:436:15: recordAssignment ( ',' recordAssignment )*
5182                                         {
5183                                         pushFollow(FOLLOW_recordAssignment_in_record3023);
5184                                         recordAssignment141=recordAssignment();
5185                                         state._fsp--;
5186                                         if (state.failed) return retval;
5187                                         if ( state.backtracking==0 ) stream_recordAssignment.add(recordAssignment141.getTree());
5188                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:436:32: ( ',' recordAssignment )*
5189                                         loop45:
5190                                         while (true) {
5191                                                 int alt45=2;
5192                                                 int LA45_0 = input.LA(1);
5193                                                 if ( (LA45_0==67) ) {
5194                                                         alt45=1;
5195                                                 }
5196
5197                                                 switch (alt45) {
5198                                                 case 1 :
5199                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:436:33: ',' recordAssignment
5200                                                         {
5201                                                         char_literal142=(Token)match(input,67,FOLLOW_67_in_record3026); if (state.failed) return retval;
5202                                                         if ( state.backtracking==0 ) stream_67.add(char_literal142);
5203
5204                                                         pushFollow(FOLLOW_recordAssignment_in_record3028);
5205                                                         recordAssignment143=recordAssignment();
5206                                                         state._fsp--;
5207                                                         if (state.failed) return retval;
5208                                                         if ( state.backtracking==0 ) stream_recordAssignment.add(recordAssignment143.getTree());
5209                                                         }
5210                                                         break;
5211
5212                                                 default :
5213                                                         break loop45;
5214                                                 }
5215                                         }
5216
5217                                         }
5218                                         break;
5219
5220                         }
5221
5222                         RCURLY144=(Token)match(input,RCURLY,FOLLOW_RCURLY_in_record3034); if (state.failed) return retval;
5223                         if ( state.backtracking==0 ) stream_RCURLY.add(RCURLY144);
5224
5225                         // AST REWRITE
5226                         // elements: recordAssignment
5227                         // token labels:
5228                         // rule labels: retval
5229                         // token list labels:
5230                         // rule list labels:
5231                         // wildcard labels:
5232                         if ( state.backtracking==0 ) {
5233                         retval.tree = root_0;
5234                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
5235
5236                         root_0 = (CommonTree)adaptor.nil();
5237                         // 437:5: -> ^( RECORD ( recordAssignment )* )
5238                         {
5239                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:437:8: ^( RECORD ( recordAssignment )* )
5240                                 {
5241                                 CommonTree root_1 = (CommonTree)adaptor.nil();
5242                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(RECORD, "RECORD"), root_1);
5243                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:437:17: ( recordAssignment )*
5244                                 while ( stream_recordAssignment.hasNext() ) {
5245                                         adaptor.addChild(root_1, stream_recordAssignment.nextTree());
5246                                 }
5247                                 stream_recordAssignment.reset();
5248
5249                                 adaptor.addChild(root_0, root_1);
5250                                 }
5251
5252                         }
5253
5254
5255                         retval.tree = root_0;
5256                         }
5257
5258                         }
5259
5260                         retval.stop = input.LT(-1);
5261
5262                         if ( state.backtracking==0 ) {
5263                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
5264                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5265                         }
5266                 }
5267                 catch (RecognitionException re) {
5268                         reportError(re);
5269                         recover(input,re);
5270                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
5271                 }
5272                 finally {
5273                         // do for sure before leaving
5274                 }
5275                 return retval;
5276         }
5277         // $ANTLR end "record"
5278
5279
5280         public static class recordAssignment_return extends ParserRuleReturnScope {
5281                 CommonTree tree;
5282                 @Override
5283                 public CommonTree getTree() { return tree; }
5284         };
5285
5286
5287         // $ANTLR start "recordAssignment"
5288         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:440:1: recordAssignment : ID '=' value -> ^( ASSIGNMENT ID value ) ;
5289         public final GraphParser.recordAssignment_return recordAssignment() throws RecognitionException {
5290                 GraphParser.recordAssignment_return retval = new GraphParser.recordAssignment_return();
5291                 retval.start = input.LT(1);
5292
5293                 CommonTree root_0 = null;
5294
5295                 Token ID145=null;
5296                 Token char_literal146=null;
5297                 ParserRuleReturnScope value147 =null;
5298
5299                 CommonTree ID145_tree=null;
5300                 CommonTree char_literal146_tree=null;
5301                 RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
5302                 RewriteRuleTokenStream stream_74=new RewriteRuleTokenStream(adaptor,"token 74");
5303                 RewriteRuleSubtreeStream stream_value=new RewriteRuleSubtreeStream(adaptor,"rule value");
5304
5305                 try {
5306                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:441:5: ( ID '=' value -> ^( ASSIGNMENT ID value ) )
5307                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:441:7: ID '=' value
5308                         {
5309                         ID145=(Token)match(input,ID,FOLLOW_ID_in_recordAssignment3066); if (state.failed) return retval;
5310                         if ( state.backtracking==0 ) stream_ID.add(ID145);
5311
5312                         char_literal146=(Token)match(input,74,FOLLOW_74_in_recordAssignment3068); if (state.failed) return retval;
5313                         if ( state.backtracking==0 ) stream_74.add(char_literal146);
5314
5315                         pushFollow(FOLLOW_value_in_recordAssignment3070);
5316                         value147=value();
5317                         state._fsp--;
5318                         if (state.failed) return retval;
5319                         if ( state.backtracking==0 ) stream_value.add(value147.getTree());
5320                         // AST REWRITE
5321                         // elements: ID, value
5322                         // token labels:
5323                         // rule labels: retval
5324                         // token list labels:
5325                         // rule list labels:
5326                         // wildcard labels:
5327                         if ( state.backtracking==0 ) {
5328                         retval.tree = root_0;
5329                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
5330
5331                         root_0 = (CommonTree)adaptor.nil();
5332                         // 442:5: -> ^( ASSIGNMENT ID value )
5333                         {
5334                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:442:8: ^( ASSIGNMENT ID value )
5335                                 {
5336                                 CommonTree root_1 = (CommonTree)adaptor.nil();
5337                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ASSIGNMENT, "ASSIGNMENT"), root_1);
5338                                 adaptor.addChild(root_1, stream_ID.nextNode());
5339                                 adaptor.addChild(root_1, stream_value.nextTree());
5340                                 adaptor.addChild(root_0, root_1);
5341                                 }
5342
5343                         }
5344
5345
5346                         retval.tree = root_0;
5347                         }
5348
5349                         }
5350
5351                         retval.stop = input.LT(-1);
5352
5353                         if ( state.backtracking==0 ) {
5354                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
5355                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5356                         }
5357                 }
5358                 catch (RecognitionException re) {
5359                         reportError(re);
5360                         recover(input,re);
5361                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
5362                 }
5363                 finally {
5364                         // do for sure before leaving
5365                 }
5366                 return retval;
5367         }
5368         // $ANTLR end "recordAssignment"
5369
5370
5371         public static class map_return extends ParserRuleReturnScope {
5372                 CommonTree tree;
5373                 @Override
5374                 public CommonTree getTree() { return tree; }
5375         };
5376
5377
5378         // $ANTLR start "map"
5379         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:445:1: map :{...}? => ID LCURLY ( mapAssignment ( ',' mapAssignment )* )? RCURLY -> ^( MAP ( mapAssignment )* ) ;
5380         public final GraphParser.map_return map() throws RecognitionException {
5381                 GraphParser.map_return retval = new GraphParser.map_return();
5382                 retval.start = input.LT(1);
5383
5384                 CommonTree root_0 = null;
5385
5386                 Token ID148=null;
5387                 Token LCURLY149=null;
5388                 Token char_literal151=null;
5389                 Token RCURLY153=null;
5390                 ParserRuleReturnScope mapAssignment150 =null;
5391                 ParserRuleReturnScope mapAssignment152 =null;
5392
5393                 CommonTree ID148_tree=null;
5394                 CommonTree LCURLY149_tree=null;
5395                 CommonTree char_literal151_tree=null;
5396                 CommonTree RCURLY153_tree=null;
5397                 RewriteRuleTokenStream stream_67=new RewriteRuleTokenStream(adaptor,"token 67");
5398                 RewriteRuleTokenStream stream_LCURLY=new RewriteRuleTokenStream(adaptor,"token LCURLY");
5399                 RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
5400                 RewriteRuleTokenStream stream_RCURLY=new RewriteRuleTokenStream(adaptor,"token RCURLY");
5401                 RewriteRuleSubtreeStream stream_mapAssignment=new RewriteRuleSubtreeStream(adaptor,"rule mapAssignment");
5402
5403                 try {
5404                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:445:5: ({...}? => ID LCURLY ( mapAssignment ( ',' mapAssignment )* )? RCURLY -> ^( MAP ( mapAssignment )* ) )
5405                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:445:7: {...}? => ID LCURLY ( mapAssignment ( ',' mapAssignment )* )? RCURLY
5406                         {
5407                         if ( !((input.LT(1).getText().equals("map"))) ) {
5408                                 if (state.backtracking>0) {state.failed=true; return retval;}
5409                                 throw new FailedPredicateException(input, "map", "input.LT(1).getText().equals(\"map\")");
5410                         }
5411                         ID148=(Token)match(input,ID,FOLLOW_ID_in_map3100); if (state.failed) return retval;
5412                         if ( state.backtracking==0 ) stream_ID.add(ID148);
5413
5414                         LCURLY149=(Token)match(input,LCURLY,FOLLOW_LCURLY_in_map3102); if (state.failed) return retval;
5415                         if ( state.backtracking==0 ) stream_LCURLY.add(LCURLY149);
5416
5417                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:445:58: ( mapAssignment ( ',' mapAssignment )* )?
5418                         int alt48=2;
5419                         int LA48_0 = input.LA(1);
5420                         if ( (LA48_0==FLOAT||LA48_0==ID||LA48_0==INT||(LA48_0 >= LBRACKET && LA48_0 <= LPAREN)||LA48_0==STRING||(LA48_0 >= 78 && LA48_0 <= 79)) ) {
5421                                 alt48=1;
5422                         }
5423                         switch (alt48) {
5424                                 case 1 :
5425                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:445:59: mapAssignment ( ',' mapAssignment )*
5426                                         {
5427                                         pushFollow(FOLLOW_mapAssignment_in_map3105);
5428                                         mapAssignment150=mapAssignment();
5429                                         state._fsp--;
5430                                         if (state.failed) return retval;
5431                                         if ( state.backtracking==0 ) stream_mapAssignment.add(mapAssignment150.getTree());
5432                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:445:73: ( ',' mapAssignment )*
5433                                         loop47:
5434                                         while (true) {
5435                                                 int alt47=2;
5436                                                 int LA47_0 = input.LA(1);
5437                                                 if ( (LA47_0==67) ) {
5438                                                         alt47=1;
5439                                                 }
5440
5441                                                 switch (alt47) {
5442                                                 case 1 :
5443                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:445:74: ',' mapAssignment
5444                                                         {
5445                                                         char_literal151=(Token)match(input,67,FOLLOW_67_in_map3108); if (state.failed) return retval;
5446                                                         if ( state.backtracking==0 ) stream_67.add(char_literal151);
5447
5448                                                         pushFollow(FOLLOW_mapAssignment_in_map3110);
5449                                                         mapAssignment152=mapAssignment();
5450                                                         state._fsp--;
5451                                                         if (state.failed) return retval;
5452                                                         if ( state.backtracking==0 ) stream_mapAssignment.add(mapAssignment152.getTree());
5453                                                         }
5454                                                         break;
5455
5456                                                 default :
5457                                                         break loop47;
5458                                                 }
5459                                         }
5460
5461                                         }
5462                                         break;
5463
5464                         }
5465
5466                         RCURLY153=(Token)match(input,RCURLY,FOLLOW_RCURLY_in_map3116); if (state.failed) return retval;
5467                         if ( state.backtracking==0 ) stream_RCURLY.add(RCURLY153);
5468
5469                         // AST REWRITE
5470                         // elements: mapAssignment
5471                         // token labels:
5472                         // rule labels: retval
5473                         // token list labels:
5474                         // rule list labels:
5475                         // wildcard labels:
5476                         if ( state.backtracking==0 ) {
5477                         retval.tree = root_0;
5478                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
5479
5480                         root_0 = (CommonTree)adaptor.nil();
5481                         // 446:5: -> ^( MAP ( mapAssignment )* )
5482                         {
5483                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:446:8: ^( MAP ( mapAssignment )* )
5484                                 {
5485                                 CommonTree root_1 = (CommonTree)adaptor.nil();
5486                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(MAP, "MAP"), root_1);
5487                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:446:14: ( mapAssignment )*
5488                                 while ( stream_mapAssignment.hasNext() ) {
5489                                         adaptor.addChild(root_1, stream_mapAssignment.nextTree());
5490                                 }
5491                                 stream_mapAssignment.reset();
5492
5493                                 adaptor.addChild(root_0, root_1);
5494                                 }
5495
5496                         }
5497
5498
5499                         retval.tree = root_0;
5500                         }
5501
5502                         }
5503
5504                         retval.stop = input.LT(-1);
5505
5506                         if ( state.backtracking==0 ) {
5507                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
5508                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5509                         }
5510                 }
5511                 catch (RecognitionException re) {
5512                         reportError(re);
5513                         recover(input,re);
5514                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
5515                 }
5516                 finally {
5517                         // do for sure before leaving
5518                 }
5519                 return retval;
5520         }
5521         // $ANTLR end "map"
5522
5523
5524         public static class mapAssignment_return extends ParserRuleReturnScope {
5525                 CommonTree tree;
5526                 @Override
5527                 public CommonTree getTree() { return tree; }
5528         };
5529
5530
5531         // $ANTLR start "mapAssignment"
5532         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:449:1: mapAssignment : value '=' value -> ^( ASSIGNMENT ( value )* ) ;
5533         public final GraphParser.mapAssignment_return mapAssignment() throws RecognitionException {
5534                 GraphParser.mapAssignment_return retval = new GraphParser.mapAssignment_return();
5535                 retval.start = input.LT(1);
5536
5537                 CommonTree root_0 = null;
5538
5539                 Token char_literal155=null;
5540                 ParserRuleReturnScope value154 =null;
5541                 ParserRuleReturnScope value156 =null;
5542
5543                 CommonTree char_literal155_tree=null;
5544                 RewriteRuleTokenStream stream_74=new RewriteRuleTokenStream(adaptor,"token 74");
5545                 RewriteRuleSubtreeStream stream_value=new RewriteRuleSubtreeStream(adaptor,"rule value");
5546
5547                 try {
5548                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:450:5: ( value '=' value -> ^( ASSIGNMENT ( value )* ) )
5549                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:450:7: value '=' value
5550                         {
5551                         pushFollow(FOLLOW_value_in_mapAssignment3148);
5552                         value154=value();
5553                         state._fsp--;
5554                         if (state.failed) return retval;
5555                         if ( state.backtracking==0 ) stream_value.add(value154.getTree());
5556                         char_literal155=(Token)match(input,74,FOLLOW_74_in_mapAssignment3150); if (state.failed) return retval;
5557                         if ( state.backtracking==0 ) stream_74.add(char_literal155);
5558
5559                         pushFollow(FOLLOW_value_in_mapAssignment3152);
5560                         value156=value();
5561                         state._fsp--;
5562                         if (state.failed) return retval;
5563                         if ( state.backtracking==0 ) stream_value.add(value156.getTree());
5564                         // AST REWRITE
5565                         // elements: value
5566                         // token labels:
5567                         // rule labels: retval
5568                         // token list labels:
5569                         // rule list labels:
5570                         // wildcard labels:
5571                         if ( state.backtracking==0 ) {
5572                         retval.tree = root_0;
5573                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
5574
5575                         root_0 = (CommonTree)adaptor.nil();
5576                         // 451:5: -> ^( ASSIGNMENT ( value )* )
5577                         {
5578                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:451:8: ^( ASSIGNMENT ( value )* )
5579                                 {
5580                                 CommonTree root_1 = (CommonTree)adaptor.nil();
5581                                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ASSIGNMENT, "ASSIGNMENT"), root_1);
5582                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:451:21: ( value )*
5583                                 while ( stream_value.hasNext() ) {
5584                                         adaptor.addChild(root_1, stream_value.nextTree());
5585                                 }
5586                                 stream_value.reset();
5587
5588                                 adaptor.addChild(root_0, root_1);
5589                                 }
5590
5591                         }
5592
5593
5594                         retval.tree = root_0;
5595                         }
5596
5597                         }
5598
5599                         retval.stop = input.LT(-1);
5600
5601                         if ( state.backtracking==0 ) {
5602                         retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
5603                         adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5604                         }
5605                 }
5606                 catch (RecognitionException re) {
5607                         reportError(re);
5608                         recover(input,re);
5609                         retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
5610                 }
5611                 finally {
5612                         // do for sure before leaving
5613                 }
5614                 return retval;
5615         }
5616         // $ANTLR end "mapAssignment"
5617
5618         // $ANTLR start synpred1_Graph
5619         public final void synpred1_Graph_fragment() throws RecognitionException {
5620                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:317:22: ( arrayType )
5621                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:317:23: arrayType
5622                 {
5623                 pushFollow(FOLLOW_arrayType_in_synpred1_Graph2075);
5624                 arrayType();
5625                 state._fsp--;
5626                 if (state.failed) return;
5627
5628                 }
5629
5630         }
5631         // $ANTLR end synpred1_Graph
5632
5633         // $ANTLR start synpred2_Graph
5634         public final void synpred2_Graph_fragment() throws RecognitionException {
5635                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:350:11: ( LPAREN )
5636                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:350:12: LPAREN
5637                 {
5638                 match(input,LPAREN,FOLLOW_LPAREN_in_synpred2_Graph2354); if (state.failed) return;
5639
5640                 }
5641
5642         }
5643         // $ANTLR end synpred2_Graph
5644
5645         // Delegated rules
5646
5647         public final boolean synpred2_Graph() {
5648                 state.backtracking++;
5649                 int start = input.mark();
5650                 try {
5651                         synpred2_Graph_fragment(); // can never throw exception
5652                 } catch (RecognitionException re) {
5653                         System.err.println("impossible: "+re);
5654                 }
5655                 boolean success = !state.failed;
5656                 input.rewind(start);
5657                 state.backtracking--;
5658                 state.failed=false;
5659                 return success;
5660         }
5661         public final boolean synpred1_Graph() {
5662                 state.backtracking++;
5663                 int start = input.mark();
5664                 try {
5665                         synpred1_Graph_fragment(); // can never throw exception
5666                 } catch (RecognitionException re) {
5667                         System.err.println("impossible: "+re);
5668                 }
5669                 boolean success = !state.failed;
5670                 input.rewind(start);
5671                 state.backtracking--;
5672                 state.failed=false;
5673                 return success;
5674         }
5675
5676
5677
5678         public static final BitSet FOLLOW_NEWLINE_in_file1230 = new BitSet(new long[]{0x0800100074440000L,0x000000000000E006L});
5679         public static final BitSet FOLLOW_resourceDefinitions_in_file1233 = new BitSet(new long[]{0x0000000000000000L});
5680         public static final BitSet FOLLOW_EOF_in_file1236 = new BitSet(new long[]{0x0000000000000002L});
5681         public static final BitSet FOLLOW_resourceDefinition_in_resourceDefinitions1260 = new BitSet(new long[]{0x0000000100000002L});
5682         public static final BitSet FOLLOW_NEWLINE_in_resourceDefinitions1263 = new BitSet(new long[]{0x0800100074440000L,0x000000000000E006L});
5683         public static final BitSet FOLLOW_resourceDefinition_in_resourceDefinitions1266 = new BitSet(new long[]{0x0000000100000002L});
5684         public static final BitSet FOLLOW_resource_in_resourceDefinition1300 = new BitSet(new long[]{0x0800000000C00002L,0x0000000000001FD4L});
5685         public static final BitSet FOLLOW_localProperty_in_resourceDefinition1308 = new BitSet(new long[]{0x0800000000C00002L,0x0000000000001FD4L});
5686         public static final BitSet FOLLOW_INDENT_in_resourceDefinition1318 = new BitSet(new long[]{0x0800000000400000L,0x0000000000003FD4L});
5687         public static final BitSet FOLLOW_property_in_resourceDefinition1320 = new BitSet(new long[]{0x0000000100000200L});
5688         public static final BitSet FOLLOW_NEWLINE_in_resourceDefinition1323 = new BitSet(new long[]{0x0800000000400000L,0x0000000000003FD4L});
5689         public static final BitSet FOLLOW_property_in_resourceDefinition1325 = new BitSet(new long[]{0x0000000100000200L});
5690         public static final BitSet FOLLOW_DEDENT_in_resourceDefinition1329 = new BitSet(new long[]{0x0000000000000002L});
5691         public static final BitSet FOLLOW_template_in_resourceDefinition1358 = new BitSet(new long[]{0x0000000000000002L});
5692         public static final BitSet FOLLOW_relation_in_localProperty1393 = new BitSet(new long[]{0x0800100074440000L,0x000000000000C006L});
5693         public static final BitSet FOLLOW_resource_in_localProperty1395 = new BitSet(new long[]{0x0000000000000002L});
5694         public static final BitSet FOLLOW_relation_in_property1434 = new BitSet(new long[]{0x0800100074C40000L,0x000000000000E006L});
5695         public static final BitSet FOLLOW_resourceDefinition_in_property1444 = new BitSet(new long[]{0x0000000000000002L});
5696         public static final BitSet FOLLOW_INDENT_in_property1464 = new BitSet(new long[]{0x0800100074440000L,0x000000000000E006L});
5697         public static final BitSet FOLLOW_resourceDefinitions_in_property1466 = new BitSet(new long[]{0x0000000000000200L});
5698         public static final BitSet FOLLOW_DEDENT_in_property1468 = new BitSet(new long[]{0x0000000000000002L});
5699         public static final BitSet FOLLOW_template_in_property1494 = new BitSet(new long[]{0x0000000000000002L});
5700         public static final BitSet FOLLOW_77_in_template1515 = new BitSet(new long[]{0x0800100074440000L,0x000000000000C006L});
5701         public static final BitSet FOLLOW_ID_in_template1533 = new BitSet(new long[]{0x0800100074440000L,0x000000000000C006L});
5702         public static final BitSet FOLLOW_resource_in_template1535 = new BitSet(new long[]{0x0800100074C40000L,0x000000000000C006L});
5703         public static final BitSet FOLLOW_INDENT_in_template1545 = new BitSet(new long[]{0x0800100074440000L,0x000000000000E006L});
5704         public static final BitSet FOLLOW_resourceDefinitions_in_template1547 = new BitSet(new long[]{0x0000000000000200L});
5705         public static final BitSet FOLLOW_DEDENT_in_template1549 = new BitSet(new long[]{0x0000000000000002L});
5706         public static final BitSet FOLLOW_resource_in_template1574 = new BitSet(new long[]{0x0800100074C40002L,0x000000000000C006L});
5707         public static final BitSet FOLLOW_INDENT_in_template1585 = new BitSet(new long[]{0x0800100074440000L,0x000000000000E006L});
5708         public static final BitSet FOLLOW_resourceDefinitions_in_template1587 = new BitSet(new long[]{0x0000000000000200L});
5709         public static final BitSet FOLLOW_DEDENT_in_template1589 = new BitSet(new long[]{0x0000000000000002L});
5710         public static final BitSet FOLLOW_ID_in_relation1643 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000020L});
5711         public static final BitSet FOLLOW_69_in_relation1658 = new BitSet(new long[]{0x0000000000400000L});
5712         public static final BitSet FOLLOW_ID_in_relation1660 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000020L});
5713         public static final BitSet FOLLOW_URI_in_relation1681 = new BitSet(new long[]{0x0000000000000002L});
5714         public static final BitSet FOLLOW_73_in_relation1689 = new BitSet(new long[]{0x0000000000000002L});
5715         public static final BitSet FOLLOW_72_in_relation1701 = new BitSet(new long[]{0x0000000000000002L});
5716         public static final BitSet FOLLOW_71_in_relation1713 = new BitSet(new long[]{0x0000000000000002L});
5717         public static final BitSet FOLLOW_68_in_relation1725 = new BitSet(new long[]{0x0000000000000002L});
5718         public static final BitSet FOLLOW_75_in_relation1737 = new BitSet(new long[]{0x0000000000000002L});
5719         public static final BitSet FOLLOW_76_in_relation1749 = new BitSet(new long[]{0x0000000000000002L});
5720         public static final BitSet FOLLOW_70_in_relation1765 = new BitSet(new long[]{0x0000000000000002L});
5721         public static final BitSet FOLLOW_74_in_relation1777 = new BitSet(new long[]{0x0000000000000002L});
5722         public static final BitSet FOLLOW_66_in_relation1789 = new BitSet(new long[]{0x0000000000400000L});
5723         public static final BitSet FOLLOW_ID_in_relation1791 = new BitSet(new long[]{0x0000000000000002L});
5724         public static final BitSet FOLLOW_ID_in_resource1821 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000020L});
5725         public static final BitSet FOLLOW_ID_in_resource1840 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000020L});
5726         public static final BitSet FOLLOW_69_in_resource1855 = new BitSet(new long[]{0x0000100000400000L});
5727         public static final BitSet FOLLOW_ID_in_resource1858 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000020L});
5728         public static final BitSet FOLLOW_STRING_in_resource1883 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000020L});
5729         public static final BitSet FOLLOW_URI_in_resource1924 = new BitSet(new long[]{0x0000000000000002L});
5730         public static final BitSet FOLLOW_simpleValue_in_resource1932 = new BitSet(new long[]{0x0000000000000002L});
5731         public static final BitSet FOLLOW_65_in_resource1948 = new BitSet(new long[]{0x0000000060400000L});
5732         public static final BitSet FOLLOW_basicType_in_resource1950 = new BitSet(new long[]{0x0000000000000002L});
5733         public static final BitSet FOLLOW_66_in_resource1966 = new BitSet(new long[]{0x0000000000400000L});
5734         public static final BitSet FOLLOW_ID_in_resource1968 = new BitSet(new long[]{0x0000000000000002L});
5735         public static final BitSet FOLLOW_arrayType_in_type2004 = new BitSet(new long[]{0x0000000000000002L});
5736         public static final BitSet FOLLOW_unionType_in_type2012 = new BitSet(new long[]{0x0000000000000002L});
5737         public static final BitSet FOLLOW_80_in_unionType2041 = new BitSet(new long[]{0x0000000000400000L});
5738         public static final BitSet FOLLOW_unionComponent_in_unionType2043 = new BitSet(new long[]{0x0000000000000002L,0x0000000000010000L});
5739         public static final BitSet FOLLOW_ID_in_unionComponent2071 = new BitSet(new long[]{0x0000000060400002L});
5740         public static final BitSet FOLLOW_arrayType_in_unionComponent2080 = new BitSet(new long[]{0x0000000000000002L});
5741         public static final BitSet FOLLOW_basicType_in_arrayType2108 = new BitSet(new long[]{0x0000000010000002L});
5742         public static final BitSet FOLLOW_LBRACKET_in_arrayType2122 = new BitSet(new long[]{0x000000100C000000L});
5743         public static final BitSet FOLLOW_arrayLength_in_arrayType2124 = new BitSet(new long[]{0x0000001000000000L});
5744         public static final BitSet FOLLOW_RBRACKET_in_arrayType2127 = new BitSet(new long[]{0x0000000010000002L});
5745         public static final BitSet FOLLOW_tupleType_in_basicType2181 = new BitSet(new long[]{0x0000000000000002L});
5746         public static final BitSet FOLLOW_recordType_in_basicType2189 = new BitSet(new long[]{0x0000000000000002L});
5747         public static final BitSet FOLLOW_typeReference_in_basicType2197 = new BitSet(new long[]{0x0000000000000002L});
5748         public static final BitSet FOLLOW_LPAREN_in_tupleType2219 = new BitSet(new long[]{0x0000080060400000L,0x0000000000010000L});
5749         public static final BitSet FOLLOW_type_in_tupleType2222 = new BitSet(new long[]{0x0000080000000000L,0x0000000000000008L});
5750         public static final BitSet FOLLOW_67_in_tupleType2225 = new BitSet(new long[]{0x0000000060400000L,0x0000000000010000L});
5751         public static final BitSet FOLLOW_type_in_tupleType2227 = new BitSet(new long[]{0x0000080000000000L,0x0000000000000008L});
5752         public static final BitSet FOLLOW_RPAREN_in_tupleType2233 = new BitSet(new long[]{0x0000000000000002L});
5753         public static final BitSet FOLLOW_LCURLY_in_recordType2266 = new BitSet(new long[]{0x0000002000400000L});
5754         public static final BitSet FOLLOW_component_in_recordType2269 = new BitSet(new long[]{0x0000002000000000L,0x0000000000000008L});
5755         public static final BitSet FOLLOW_67_in_recordType2272 = new BitSet(new long[]{0x0000000000400000L});
5756         public static final BitSet FOLLOW_component_in_recordType2274 = new BitSet(new long[]{0x0000002000000000L,0x0000000000000008L});
5757         public static final BitSet FOLLOW_RCURLY_in_recordType2280 = new BitSet(new long[]{0x0000000000000002L});
5758         public static final BitSet FOLLOW_ID_in_component2312 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
5759         public static final BitSet FOLLOW_70_in_component2314 = new BitSet(new long[]{0x0000000060400000L,0x0000000000010000L});
5760         public static final BitSet FOLLOW_type_in_component2316 = new BitSet(new long[]{0x0000000000000002L});
5761         public static final BitSet FOLLOW_ID_in_typeReference2350 = new BitSet(new long[]{0x0000000040000002L});
5762         public static final BitSet FOLLOW_LPAREN_in_typeReference2358 = new BitSet(new long[]{0x0000000060400000L,0x0000000000010000L});
5763         public static final BitSet FOLLOW_parameter_in_typeReference2360 = new BitSet(new long[]{0x0000080000000000L,0x0000000000000008L});
5764         public static final BitSet FOLLOW_67_in_typeReference2363 = new BitSet(new long[]{0x0000000060400000L,0x0000000000010000L});
5765         public static final BitSet FOLLOW_parameter_in_typeReference2365 = new BitSet(new long[]{0x0000080000000000L,0x0000000000000008L});
5766         public static final BitSet FOLLOW_RPAREN_in_typeReference2369 = new BitSet(new long[]{0x0000000000000002L});
5767         public static final BitSet FOLLOW_ID_in_parameter2405 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L});
5768         public static final BitSet FOLLOW_74_in_parameter2407 = new BitSet(new long[]{0x0000100054040000L,0x000000000000C000L});
5769         public static final BitSet FOLLOW_parameterValue_in_parameter2409 = new BitSet(new long[]{0x0000000000000002L});
5770         public static final BitSet FOLLOW_type_in_parameter2427 = new BitSet(new long[]{0x0000000000000002L});
5771         public static final BitSet FOLLOW_string_in_parameterValue2446 = new BitSet(new long[]{0x0000000000000002L});
5772         public static final BitSet FOLLOW_boolean__in_parameterValue2454 = new BitSet(new long[]{0x0000000000000002L});
5773         public static final BitSet FOLLOW_number_in_parameterValue2462 = new BitSet(new long[]{0x0000000000000002L});
5774         public static final BitSet FOLLOW_rangePar_in_parameterValue2470 = new BitSet(new long[]{0x0000000000000002L});
5775         public static final BitSet FOLLOW_set_in_rangePar2499 = new BitSet(new long[]{0x000000080C040000L});
5776         public static final BitSet FOLLOW_range_in_rangePar2507 = new BitSet(new long[]{0x0000081000000000L});
5777         public static final BitSet FOLLOW_set_in_rangePar2509 = new BitSet(new long[]{0x0000000000000002L});
5778         public static final BitSet FOLLOW_number_in_range2536 = new BitSet(new long[]{0x0000000000000002L});
5779         public static final BitSet FOLLOW_RANGE_in_range2544 = new BitSet(new long[]{0x0000000000000002L});
5780         public static final BitSet FOLLOW_INT_RANGE_in_range2552 = new BitSet(new long[]{0x0000000000000002L});
5781         public static final BitSet FOLLOW_STRING_in_string2606 = new BitSet(new long[]{0x0000000000000002L});
5782         public static final BitSet FOLLOW_79_in_boolean_2627 = new BitSet(new long[]{0x0000000000000002L});
5783         public static final BitSet FOLLOW_78_in_boolean_2639 = new BitSet(new long[]{0x0000000000000002L});
5784         public static final BitSet FOLLOW_valueDefinition_in_valueDefinitions2660 = new BitSet(new long[]{0x0000000000400002L});
5785         public static final BitSet FOLLOW_ID_in_valueDefinition2683 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
5786         public static final BitSet FOLLOW_70_in_valueDefinition2685 = new BitSet(new long[]{0x0000000060400000L,0x0000000000010000L});
5787         public static final BitSet FOLLOW_type_in_valueDefinition2687 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L});
5788         public static final BitSet FOLLOW_74_in_valueDefinition2689 = new BitSet(new long[]{0x0000100074440000L,0x000000000000C000L});
5789         public static final BitSet FOLLOW_value_in_valueDefinition2691 = new BitSet(new long[]{0x0000000000000002L});
5790         public static final BitSet FOLLOW_basicValue_in_value2727 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000040L});
5791         public static final BitSet FOLLOW_70_in_value2741 = new BitSet(new long[]{0x0000000060400000L,0x0000000000010000L});
5792         public static final BitSet FOLLOW_type_in_value2743 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000040L});
5793         public static final BitSet FOLLOW_simpleValue_in_basicValue2775 = new BitSet(new long[]{0x0000000000000002L});
5794         public static final BitSet FOLLOW_map_in_basicValue2783 = new BitSet(new long[]{0x0000000000000002L});
5795         public static final BitSet FOLLOW_ID_in_basicValue2793 = new BitSet(new long[]{0x0000000000000002L});
5796         public static final BitSet FOLLOW_taggedValue_in_basicValue2805 = new BitSet(new long[]{0x0000000000000002L});
5797         public static final BitSet FOLLOW_string_in_simpleValue2830 = new BitSet(new long[]{0x0000000000000002L});
5798         public static final BitSet FOLLOW_number_in_simpleValue2838 = new BitSet(new long[]{0x0000000000000002L});
5799         public static final BitSet FOLLOW_boolean__in_simpleValue2846 = new BitSet(new long[]{0x0000000000000002L});
5800         public static final BitSet FOLLOW_array_in_simpleValue2854 = new BitSet(new long[]{0x0000000000000002L});
5801         public static final BitSet FOLLOW_tuple_in_simpleValue2862 = new BitSet(new long[]{0x0000000000000002L});
5802         public static final BitSet FOLLOW_record_in_simpleValue2870 = new BitSet(new long[]{0x0000000000000002L});
5803         public static final BitSet FOLLOW_LBRACKET_in_array2891 = new BitSet(new long[]{0x0000101074440000L,0x000000000000C000L});
5804         public static final BitSet FOLLOW_value_in_array2894 = new BitSet(new long[]{0x0000001000000000L,0x0000000000000008L});
5805         public static final BitSet FOLLOW_67_in_array2897 = new BitSet(new long[]{0x0000100074440000L,0x000000000000C000L});
5806         public static final BitSet FOLLOW_value_in_array2899 = new BitSet(new long[]{0x0000001000000000L,0x0000000000000008L});
5807         public static final BitSet FOLLOW_RBRACKET_in_array2905 = new BitSet(new long[]{0x0000000000000002L});
5808         public static final BitSet FOLLOW_LPAREN_in_tuple2937 = new BitSet(new long[]{0x0000180074440000L,0x000000000000C000L});
5809         public static final BitSet FOLLOW_value_in_tuple2940 = new BitSet(new long[]{0x0000080000000000L,0x0000000000000008L});
5810         public static final BitSet FOLLOW_67_in_tuple2943 = new BitSet(new long[]{0x0000100074440000L,0x000000000000C000L});
5811         public static final BitSet FOLLOW_value_in_tuple2945 = new BitSet(new long[]{0x0000080000000000L,0x0000000000000008L});
5812         public static final BitSet FOLLOW_RPAREN_in_tuple2951 = new BitSet(new long[]{0x0000000000000002L});
5813         public static final BitSet FOLLOW_ID_in_taggedValue2983 = new BitSet(new long[]{0x0000100074040002L,0x000000000000C000L});
5814         public static final BitSet FOLLOW_simpleValue_in_taggedValue2985 = new BitSet(new long[]{0x0000000000000002L});
5815         public static final BitSet FOLLOW_LCURLY_in_record3020 = new BitSet(new long[]{0x0000002000400000L});
5816         public static final BitSet FOLLOW_recordAssignment_in_record3023 = new BitSet(new long[]{0x0000002000000000L,0x0000000000000008L});
5817         public static final BitSet FOLLOW_67_in_record3026 = new BitSet(new long[]{0x0000000000400000L});
5818         public static final BitSet FOLLOW_recordAssignment_in_record3028 = new BitSet(new long[]{0x0000002000000000L,0x0000000000000008L});
5819         public static final BitSet FOLLOW_RCURLY_in_record3034 = new BitSet(new long[]{0x0000000000000002L});
5820         public static final BitSet FOLLOW_ID_in_recordAssignment3066 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L});
5821         public static final BitSet FOLLOW_74_in_recordAssignment3068 = new BitSet(new long[]{0x0000100074440000L,0x000000000000C000L});
5822         public static final BitSet FOLLOW_value_in_recordAssignment3070 = new BitSet(new long[]{0x0000000000000002L});
5823         public static final BitSet FOLLOW_ID_in_map3100 = new BitSet(new long[]{0x0000000020000000L});
5824         public static final BitSet FOLLOW_LCURLY_in_map3102 = new BitSet(new long[]{0x0000102074440000L,0x000000000000C000L});
5825         public static final BitSet FOLLOW_mapAssignment_in_map3105 = new BitSet(new long[]{0x0000002000000000L,0x0000000000000008L});
5826         public static final BitSet FOLLOW_67_in_map3108 = new BitSet(new long[]{0x0000100074440000L,0x000000000000C000L});
5827         public static final BitSet FOLLOW_mapAssignment_in_map3110 = new BitSet(new long[]{0x0000002000000000L,0x0000000000000008L});
5828         public static final BitSet FOLLOW_RCURLY_in_map3116 = new BitSet(new long[]{0x0000000000000002L});
5829         public static final BitSet FOLLOW_value_in_mapAssignment3148 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L});
5830         public static final BitSet FOLLOW_74_in_mapAssignment3150 = new BitSet(new long[]{0x0000100074440000L,0x000000000000C000L});
5831         public static final BitSet FOLLOW_value_in_mapAssignment3152 = new BitSet(new long[]{0x0000000000000002L});
5832         public static final BitSet FOLLOW_arrayType_in_synpred1_Graph2075 = new BitSet(new long[]{0x0000000000000002L});
5833         public static final BitSet FOLLOW_LPAREN_in_synpred2_Graph2354 = new BitSet(new long[]{0x0000000000000002L});
5834 }