bundles/org.simantics.graph.compiler/src/org/simantics/graph/compiler/internal/parsing/GraphLexer.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 gnu.trove.list.array.*;
   5
   6
   7 import org.antlr.runtime.*;
   8 import java.util.Stack;
   9 import java.util.List;
  10 import java.util.ArrayList;
  11
  12 @SuppressWarnings("all")
  13 public class GraphLexer extends Lexer {
  14         public static final int EOF=-1;
  15         public static final int T__65=65;
  16         public static final int T__66=66;
  17         public static final int T__67=67;
  18         public static final int T__68=68;
  19         public static final int T__69=69;
  20         public static final int T__70=70;
  21         public static final int T__71=71;
  22         public static final int T__72=72;
  23         public static final int T__73=73;
  24         public static final int T__74=74;
  25         public static final int T__75=75;
  26         public static final int T__76=76;
  27         public static final int T__77=77;
  28         public static final int T__78=78;
  29         public static final int T__79=79;
  30         public static final int T__80=80;
  31         public static final int ARRAY=4;
  32         public static final int ARRAY_TYPE=5;
  33         public static final int ASSIGNMENT=6;
  34         public static final int BLANK=7;
  35         public static final int COMMENT=8;
  36         public static final int DEDENT=9;
  37         public static final int DOMAIN_OF=10;
  38         public static final int EMBEDDED_TYPE=11;
  39         public static final int EMBEDDED_VALUE=12;
  40         public static final int EQUALS=13;
  41         public static final int ESC_SEQ=14;
  42         public static final int EXPONENT=15;
  43         public static final int FALSE=16;
  44         public static final int FILE=17;
  45         public static final int FLOAT=18;
  46         public static final int HAS_DOMAIN=19;
  47         public static final int HAS_RANGE=20;
  48         public static final int HEX_DIGIT=21;
  49         public static final int ID=22;
  50         public static final int INDENT=23;
  51         public static final int INHERITS=24;
  52         public static final int INSTANCE_OF=25;
  53         public static final int INT=26;
  54         public static final int INT_RANGE=27;
  55         public static final int LBRACKET=28;
  56         public static final int LCURLY=29;
  57         public static final int LPAREN=30;
  58         public static final int MAP=31;
  59         public static final int NEWLINE=32;
  60         public static final int NO_VALUE=33;
  61         public static final int PROPERTY=34;
  62         public static final int RANGE=35;
  63         public static final int RBRACKET=36;
  64         public static final int RCURLY=37;
  65         public static final int RECORD=38;
  66         public static final int RECORD_TYPE=39;
  67         public static final int REF=40;
  68         public static final int REQUIRES_VALUE_TYPE=41;
  69         public static final int RESOURCE=42;
  70         public static final int RPAREN=43;
  71         public static final int STRING=44;
  72         public static final int SUBRELATION_OF=45;
  73         public static final int TAGGED_VALUE=46;
  74         public static final int TEMPLATE_DEFINITION=47;
  75         public static final int TEMPLATE_INSTANCE=48;
  76         public static final int TRUE=49;
  77         public static final int TUPLE=50;
  78         public static final int TUPLE_TYPE=51;
  79         public static final int TYPE_ANNOTATION=52;
  80         public static final int TYPE_COMPONENT=53;
  81         public static final int TYPE_DEFINITION=54;
  82         public static final int TYPE_DEFINITIONS=55;
  83         public static final int TYPE_REFERENCE=56;
  84         public static final int UNICODE_ESC=57;
  85         public static final int UNION_TYPE=58;
  86         public static final int URI=59;
  87         public static final int VALUE_DEFINITION=60;
  88         public static final int VALUE_DEFINITIONS=61;
  89         public static final int VARIABLE=62;
  90         public static final int VARIANT=63;
  91         public static final int WS=64;
  92
  93         int inParen = 0;
  94
  95         TIntArrayList iStack = new TIntArrayList();
  96         { iStack.add(0); }
  97
  98         List tokens = new ArrayList();
  99         public void emit(Token token) {
 100             state.token = token;
 101             tokens.add(token);
 102         }
 103         public Token nextToken() {
 104             if(tokens.isEmpty()) {
 105                 super.nextToken();
 106                 if ( tokens.isEmpty() ) {
 107                     /* When end-of-file is encountered, we
 108                        emit balancing number of DEDENT tokens.
 109                     */
 110                     if(iStack.size() <= 1)
 111                         return getEOFToken();
 112                     else {
 113                         while(iStack.size() > 1) {
 114                             iStack.removeAt(iStack.size()-1);
 115                             state.type = DEDENT;
 116                             emit();
 117                         }
 118                         iStack.clear();
 119                     }
 120                 }
 121             }
 122             return (Token)tokens.remove(0);
 123         }
 124
 125
 126
 127         // delegates
 128         // delegators
 129         public Lexer[] getDelegates() {
 130                 return new Lexer[] {};
 131         }
 132
 133         public GraphLexer() {}
 134         public GraphLexer(CharStream input) {
 135                 this(input, new RecognizerSharedState());
 136         }
 137         public GraphLexer(CharStream input, RecognizerSharedState state) {
 138                 super(input,state);
 139         }
 140         @Override public String getGrammarFileName() { return "src/org/simantics/graph/compiler/internal/parsing/Graph.g"; }
 141
 142         // $ANTLR start "T__65"
 143         public final void mT__65() throws RecognitionException {
 144                 try {
 145                         int _type = T__65;
 146                         int _channel = DEFAULT_TOKEN_CHANNEL;
 147                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:46:7: ( '$' )
 148                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:46:9: '$'
 149                         {
 150                         match('$');
 151                         }
 152
 153                         state.type = _type;
 154                         state.channel = _channel;
 155                 }
 156                 finally {
 157                         // do for sure before leaving
 158                 }
 159         }
 160         // $ANTLR end "T__65"
 161
 162         // $ANTLR start "T__66"
 163         public final void mT__66() throws RecognitionException {
 164                 try {
 165                         int _type = T__66;
 166                         int _channel = DEFAULT_TOKEN_CHANNEL;
 167                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:47:7: ( '%' )
 168                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:47:9: '%'
 169                         {
 170                         match('%');
 171                         }
 172
 173                         state.type = _type;
 174                         state.channel = _channel;
 175                 }
 176                 finally {
 177                         // do for sure before leaving
 178                 }
 179         }
 180         // $ANTLR end "T__66"
 181
 182         // $ANTLR start "T__67"
 183         public final void mT__67() throws RecognitionException {
 184                 try {
 185                         int _type = T__67;
 186                         int _channel = DEFAULT_TOKEN_CHANNEL;
 187                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:48:7: ( ',' )
 188                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:48:9: ','
 189                         {
 190                         match(',');
 191                         }
 192
 193                         state.type = _type;
 194                         state.channel = _channel;
 195                 }
 196                 finally {
 197                         // do for sure before leaving
 198                 }
 199         }
 200         // $ANTLR end "T__67"
 201
 202         // $ANTLR start "T__68"
 203         public final void mT__68() throws RecognitionException {
 204                 try {
 205                         int _type = T__68;
 206                         int _channel = DEFAULT_TOKEN_CHANNEL;
 207                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:49:7: ( '-->' )
 208                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:49:9: '-->'
 209                         {
 210                         match("-->");
 211
 212                         }
 213
 214                         state.type = _type;
 215                         state.channel = _channel;
 216                 }
 217                 finally {
 218                         // do for sure before leaving
 219                 }
 220         }
 221         // $ANTLR end "T__68"
 222
 223         // $ANTLR start "T__69"
 224         public final void mT__69() throws RecognitionException {
 225                 try {
 226                         int _type = T__69;
 227                         int _channel = DEFAULT_TOKEN_CHANNEL;
 228                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:50:7: ( '.' )
 229                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:50:9: '.'
 230                         {
 231                         match('.');
 232                         }
 233
 234                         state.type = _type;
 235                         state.channel = _channel;
 236                 }
 237                 finally {
 238                         // do for sure before leaving
 239                 }
 240         }
 241         // $ANTLR end "T__69"
 242
 243         // $ANTLR start "T__70"
 244         public final void mT__70() throws RecognitionException {
 245                 try {
 246                         int _type = T__70;
 247                         int _channel = DEFAULT_TOKEN_CHANNEL;
 248                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:51:7: ( ':' )
 249                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:51:9: ':'
 250                         {
 251                         match(':');
 252                         }
 253
 254                         state.type = _type;
 255                         state.channel = _channel;
 256                 }
 257                 finally {
 258                         // do for sure before leaving
 259                 }
 260         }
 261         // $ANTLR end "T__70"
 262
 263         // $ANTLR start "T__71"
 264         public final void mT__71() throws RecognitionException {
 265                 try {
 266                         int _type = T__71;
 267                         int _channel = DEFAULT_TOKEN_CHANNEL;
 268                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:52:7: ( '<--' )
 269                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:52:9: '<--'
 270                         {
 271                         match("<--");
 272
 273                         }
 274
 275                         state.type = _type;
 276                         state.channel = _channel;
 277                 }
 278                 finally {
 279                         // do for sure before leaving
 280                 }
 281         }
 282         // $ANTLR end "T__71"
 283
 284         // $ANTLR start "T__72"
 285         public final void mT__72() throws RecognitionException {
 286                 try {
 287                         int _type = T__72;
 288                         int _channel = DEFAULT_TOKEN_CHANNEL;
 289                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:53:7: ( '<R' )
 290                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:53:9: '<R'
 291                         {
 292                         match("<R");
 293
 294                         }
 295
 296                         state.type = _type;
 297                         state.channel = _channel;
 298                 }
 299                 finally {
 300                         // do for sure before leaving
 301                 }
 302         }
 303         // $ANTLR end "T__72"
 304
 305         // $ANTLR start "T__73"
 306         public final void mT__73() throws RecognitionException {
 307                 try {
 308                         int _type = T__73;
 309                         int _channel = DEFAULT_TOKEN_CHANNEL;
 310                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:54:7: ( '<T' )
 311                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:54:9: '<T'
 312                         {
 313                         match("<T");
 314
 315                         }
 316
 317                         state.type = _type;
 318                         state.channel = _channel;
 319                 }
 320                 finally {
 321                         // do for sure before leaving
 322                 }
 323         }
 324         // $ANTLR end "T__73"
 325
 326         // $ANTLR start "T__74"
 327         public final void mT__74() throws RecognitionException {
 328                 try {
 329                         int _type = T__74;
 330                         int _channel = DEFAULT_TOKEN_CHANNEL;
 331                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:55:7: ( '=' )
 332                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:55:9: '='
 333                         {
 334                         match('=');
 335                         }
 336
 337                         state.type = _type;
 338                         state.channel = _channel;
 339                 }
 340                 finally {
 341                         // do for sure before leaving
 342                 }
 343         }
 344         // $ANTLR end "T__74"
 345
 346         // $ANTLR start "T__75"
 347         public final void mT__75() throws RecognitionException {
 348                 try {
 349                         int _type = T__75;
 350                         int _channel = DEFAULT_TOKEN_CHANNEL;
 351                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:56:7: ( '==>' )
 352                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:56:9: '==>'
 353                         {
 354                         match("==>");
 355
 356                         }
 357
 358                         state.type = _type;
 359                         state.channel = _channel;
 360                 }
 361                 finally {
 362                         // do for sure before leaving
 363                 }
 364         }
 365         // $ANTLR end "T__75"
 366
 367         // $ANTLR start "T__76"
 368         public final void mT__76() throws RecognitionException {
 369                 try {
 370                         int _type = T__76;
 371                         int _channel = DEFAULT_TOKEN_CHANNEL;
 372                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:57:7: ( '>--' )
 373                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:57:9: '>--'
 374                         {
 375                         match(">--");
 376
 377                         }
 378
 379                         state.type = _type;
 380                         state.channel = _channel;
 381                 }
 382                 finally {
 383                         // do for sure before leaving
 384                 }
 385         }
 386         // $ANTLR end "T__76"
 387
 388         // $ANTLR start "T__77"
 389         public final void mT__77() throws RecognitionException {
 390                 try {
 391                         int _type = T__77;
 392                         int _channel = DEFAULT_TOKEN_CHANNEL;
 393                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:58:7: ( '@' )
 394                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:58:9: '@'
 395                         {
 396                         match('@');
 397                         }
 398
 399                         state.type = _type;
 400                         state.channel = _channel;
 401                 }
 402                 finally {
 403                         // do for sure before leaving
 404                 }
 405         }
 406         // $ANTLR end "T__77"
 407
 408         // $ANTLR start "T__78"
 409         public final void mT__78() throws RecognitionException {
 410                 try {
 411                         int _type = T__78;
 412                         int _channel = DEFAULT_TOKEN_CHANNEL;
 413                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:59:7: ( 'false' )
 414                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:59:9: 'false'
 415                         {
 416                         match("false");
 417
 418                         }
 419
 420                         state.type = _type;
 421                         state.channel = _channel;
 422                 }
 423                 finally {
 424                         // do for sure before leaving
 425                 }
 426         }
 427         // $ANTLR end "T__78"
 428
 429         // $ANTLR start "T__79"
 430         public final void mT__79() throws RecognitionException {
 431                 try {
 432                         int _type = T__79;
 433                         int _channel = DEFAULT_TOKEN_CHANNEL;
 434                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:60:7: ( 'true' )
 435                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:60:9: 'true'
 436                         {
 437                         match("true");
 438
 439                         }
 440
 441                         state.type = _type;
 442                         state.channel = _channel;
 443                 }
 444                 finally {
 445                         // do for sure before leaving
 446                 }
 447         }
 448         // $ANTLR end "T__79"
 449
 450         // $ANTLR start "T__80"
 451         public final void mT__80() throws RecognitionException {
 452                 try {
 453                         int _type = T__80;
 454                         int _channel = DEFAULT_TOKEN_CHANNEL;
 455                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:61:7: ( '|' )
 456                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:61:9: '|'
 457                         {
 458                         match('|');
 459                         }
 460
 461                         state.type = _type;
 462                         state.channel = _channel;
 463                 }
 464                 finally {
 465                         // do for sure before leaving
 466                 }
 467         }
 468         // $ANTLR end "T__80"
 469
 470         // $ANTLR start "ID"
 471         public final void mID() throws RecognitionException {
 472                 try {
 473                         int _type = ID;
 474                         int _channel = DEFAULT_TOKEN_CHANNEL;
 475                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:108:5: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )* )
 476                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:108:7: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
 477                         {
 478                         if ( (input.LA(1) >= 'A' && input.LA(1) <= 'Z')||input.LA(1)=='_'||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
 479                                 input.consume();
 480                         }
 481                         else {
 482                                 MismatchedSetException mse = new MismatchedSetException(null,input);
 483                                 recover(mse);
 484                                 throw mse;
 485                         }
 486                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:108:31: ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
 487                         loop1:
 488                         while (true) {
 489                                 int alt1=2;
 490                                 int LA1_0 = input.LA(1);
 491                                 if ( ((LA1_0 >= '0' && LA1_0 <= '9')||(LA1_0 >= 'A' && LA1_0 <= 'Z')||LA1_0=='_'||(LA1_0 >= 'a' && LA1_0 <= 'z')) ) {
 492                                         alt1=1;
 493                                 }
 494
 495                                 switch (alt1) {
 496                                 case 1 :
 497                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:
 498                                         {
 499                                         if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'Z')||input.LA(1)=='_'||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
 500                                                 input.consume();
 501                                         }
 502                                         else {
 503                                                 MismatchedSetException mse = new MismatchedSetException(null,input);
 504                                                 recover(mse);
 505                                                 throw mse;
 506                                         }
 507                                         }
 508                                         break;
 509
 510                                 default :
 511                                         break loop1;
 512                                 }
 513                         }
 514
 515                         }
 516
 517                         state.type = _type;
 518                         state.channel = _channel;
 519                 }
 520                 finally {
 521                         // do for sure before leaving
 522                 }
 523         }
 524         // $ANTLR end "ID"
 525
 526         // $ANTLR start "COMMENT"
 527         public final void mCOMMENT() throws RecognitionException {
 528                 try {
 529                         int _type = COMMENT;
 530                         int _channel = DEFAULT_TOKEN_CHANNEL;
 531                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:112:5: ( '//' (~ ( '\\n' ) )* | '/*' ( options {greedy=false; } : . )* '*/' )
 532                         int alt4=2;
 533                         int LA4_0 = input.LA(1);
 534                         if ( (LA4_0=='/') ) {
 535                                 int LA4_1 = input.LA(2);
 536                                 if ( (LA4_1=='/') ) {
 537                                         alt4=1;
 538                                 }
 539                                 else if ( (LA4_1=='*') ) {
 540                                         alt4=2;
 541                                 }
 542
 543                                 else {
 544                                         int nvaeMark = input.mark();
 545                                         try {
 546                                                 input.consume();
 547                                                 NoViableAltException nvae =
 548                                                         new NoViableAltException("", 4, 1, input);
 549                                                 throw nvae;
 550                                         } finally {
 551                                                 input.rewind(nvaeMark);
 552                                         }
 553                                 }
 554
 555                         }
 556
 557                         else {
 558                                 NoViableAltException nvae =
 559                                         new NoViableAltException("", 4, 0, input);
 560                                 throw nvae;
 561                         }
 562
 563                         switch (alt4) {
 564                                 case 1 :
 565                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:112:9: '//' (~ ( '\\n' ) )*
 566                                         {
 567                                         match("//");
 568
 569                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:112:14: (~ ( '\\n' ) )*
 570                                         loop2:
 571                                         while (true) {
 572                                                 int alt2=2;
 573                                                 int LA2_0 = input.LA(1);
 574                                                 if ( ((LA2_0 >= '\u0000' && LA2_0 <= '\t')||(LA2_0 >= '\u000B' && LA2_0 <= '\uFFFF')) ) {
 575                                                         alt2=1;
 576                                                 }
 577
 578                                                 switch (alt2) {
 579                                                 case 1 :
 580                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:
 581                                                         {
 582                                                         if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '\t')||(input.LA(1) >= '\u000B' && input.LA(1) <= '\uFFFF') ) {
 583                                                                 input.consume();
 584                                                         }
 585                                                         else {
 586                                                                 MismatchedSetException mse = new MismatchedSetException(null,input);
 587                                                                 recover(mse);
 588                                                                 throw mse;
 589                                                         }
 590                                                         }
 591                                                         break;
 592
 593                                                 default :
 594                                                         break loop2;
 595                                                 }
 596                                         }
 597
 598                                         _channel=HIDDEN;
 599                                         }
 600                                         break;
 601                                 case 2 :
 602                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:113:9: '/*' ( options {greedy=false; } : . )* '*/'
 603                                         {
 604                                         match("/*");
 605
 606                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:113:14: ( options {greedy=false; } : . )*
 607                                         loop3:
 608                                         while (true) {
 609                                                 int alt3=2;
 610                                                 int LA3_0 = input.LA(1);
 611                                                 if ( (LA3_0=='*') ) {
 612                                                         int LA3_1 = input.LA(2);
 613                                                         if ( (LA3_1=='/') ) {
 614                                                                 alt3=2;
 615                                                         }
 616                                                         else if ( ((LA3_1 >= '\u0000' && LA3_1 <= '.')||(LA3_1 >= '0' && LA3_1 <= '\uFFFF')) ) {
 617                                                                 alt3=1;
 618                                                         }
 619
 620                                                 }
 621                                                 else if ( ((LA3_0 >= '\u0000' && LA3_0 <= ')')||(LA3_0 >= '+' && LA3_0 <= '\uFFFF')) ) {
 622                                                         alt3=1;
 623                                                 }
 624
 625                                                 switch (alt3) {
 626                                                 case 1 :
 627                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:113:42: .
 628                                                         {
 629                                                         matchAny();
 630                                                         }
 631                                                         break;
 632
 633                                                 default :
 634                                                         break loop3;
 635                                                 }
 636                                         }
 637
 638                                         match("*/");
 639
 640                                         _channel=HIDDEN;
 641                                         }
 642                                         break;
 643
 644                         }
 645                         state.type = _type;
 646                         state.channel = _channel;
 647                 }
 648                 finally {
 649                         // do for sure before leaving
 650                 }
 651         }
 652         // $ANTLR end "COMMENT"
 653
 654         // $ANTLR start "WS"
 655         public final void mWS() throws RecognitionException {
 656                 try {
 657                         int _type = WS;
 658                         int _channel = DEFAULT_TOKEN_CHANNEL;
 659                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:116:5: ( ( ' ' | '\\t' | '\\r' ) )
 660                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:116:7: ( ' ' | '\\t' | '\\r' )
 661                         {
 662                         if ( input.LA(1)=='\t'||input.LA(1)=='\r'||input.LA(1)==' ' ) {
 663                                 input.consume();
 664                         }
 665                         else {
 666                                 MismatchedSetException mse = new MismatchedSetException(null,input);
 667                                 recover(mse);
 668                                 throw mse;
 669                         }
 670                         _channel=HIDDEN;
 671                         }
 672
 673                         state.type = _type;
 674                         state.channel = _channel;
 675                 }
 676                 finally {
 677                         // do for sure before leaving
 678                 }
 679         }
 680         // $ANTLR end "WS"
 681
 682         // $ANTLR start "LPAREN"
 683         public final void mLPAREN() throws RecognitionException {
 684                 try {
 685                         int _type = LPAREN;
 686                         int _channel = DEFAULT_TOKEN_CHANNEL;
 687                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:122:11: ( '(' )
 688                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:122:13: '('
 689                         {
 690                         match('(');
 691                          ++ inParen;
 692                         }
 693
 694                         state.type = _type;
 695                         state.channel = _channel;
 696                 }
 697                 finally {
 698                         // do for sure before leaving
 699                 }
 700         }
 701         // $ANTLR end "LPAREN"
 702
 703         // $ANTLR start "RPAREN"
 704         public final void mRPAREN() throws RecognitionException {
 705                 try {
 706                         int _type = RPAREN;
 707                         int _channel = DEFAULT_TOKEN_CHANNEL;
 708                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:123:11: ( ')' )
 709                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:123:13: ')'
 710                         {
 711                         match(')');
 712                          -- inParen;
 713                         }
 714
 715                         state.type = _type;
 716                         state.channel = _channel;
 717                 }
 718                 finally {
 719                         // do for sure before leaving
 720                 }
 721         }
 722         // $ANTLR end "RPAREN"
 723
 724         // $ANTLR start "LBRACKET"
 725         public final void mLBRACKET() throws RecognitionException {
 726                 try {
 727                         int _type = LBRACKET;
 728                         int _channel = DEFAULT_TOKEN_CHANNEL;
 729                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:124:11: ( '[' )
 730                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:124:13: '['
 731                         {
 732                         match('[');
 733                          ++ inParen;
 734                         }
 735
 736                         state.type = _type;
 737                         state.channel = _channel;
 738                 }
 739                 finally {
 740                         // do for sure before leaving
 741                 }
 742         }
 743         // $ANTLR end "LBRACKET"
 744
 745         // $ANTLR start "RBRACKET"
 746         public final void mRBRACKET() throws RecognitionException {
 747                 try {
 748                         int _type = RBRACKET;
 749                         int _channel = DEFAULT_TOKEN_CHANNEL;
 750                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:125:11: ( ']' )
 751                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:125:13: ']'
 752                         {
 753                         match(']');
 754                          -- inParen;
 755                         }
 756
 757                         state.type = _type;
 758                         state.channel = _channel;
 759                 }
 760                 finally {
 761                         // do for sure before leaving
 762                 }
 763         }
 764         // $ANTLR end "RBRACKET"
 765
 766         // $ANTLR start "LCURLY"
 767         public final void mLCURLY() throws RecognitionException {
 768                 try {
 769                         int _type = LCURLY;
 770                         int _channel = DEFAULT_TOKEN_CHANNEL;
 771                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:126:11: ( '{' )
 772                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:126:13: '{'
 773                         {
 774                         match('{');
 775                          ++ inParen;
 776                         }
 777
 778                         state.type = _type;
 779                         state.channel = _channel;
 780                 }
 781                 finally {
 782                         // do for sure before leaving
 783                 }
 784         }
 785         // $ANTLR end "LCURLY"
 786
 787         // $ANTLR start "RCURLY"
 788         public final void mRCURLY() throws RecognitionException {
 789                 try {
 790                         int _type = RCURLY;
 791                         int _channel = DEFAULT_TOKEN_CHANNEL;
 792                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:127:11: ( '}' )
 793                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:127:13: '}'
 794                         {
 795                         match('}');
 796                          -- inParen;
 797                         }
 798
 799                         state.type = _type;
 800                         state.channel = _channel;
 801                 }
 802                 finally {
 803                         // do for sure before leaving
 804                 }
 805         }
 806         // $ANTLR end "RCURLY"
 807
 808         // $ANTLR start "INT_RANGE"
 809         public final void mINT_RANGE() throws RecognitionException {
 810                 try {
 811                         int _type = INT_RANGE;
 812                         int _channel = DEFAULT_TOKEN_CHANNEL;
 813                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:129:11: ( INT '..' ( INT )? | '..' INT )
 814                         int alt6=2;
 815                         int LA6_0 = input.LA(1);
 816                         if ( (LA6_0=='-'||(LA6_0 >= '0' && LA6_0 <= '9')) ) {
 817                                 alt6=1;
 818                         }
 819                         else if ( (LA6_0=='.') ) {
 820                                 alt6=2;
 821                         }
 822
 823                         else {
 824                                 NoViableAltException nvae =
 825                                         new NoViableAltException("", 6, 0, input);
 826                                 throw nvae;
 827                         }
 828
 829                         switch (alt6) {
 830                                 case 1 :
 831                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:129:13: INT '..' ( INT )?
 832                                         {
 833                                         mINT();
 834
 835                                         match("..");
 836
 837                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:129:22: ( INT )?
 838                                         int alt5=2;
 839                                         int LA5_0 = input.LA(1);
 840                                         if ( (LA5_0=='-'||(LA5_0 >= '0' && LA5_0 <= '9')) ) {
 841                                                 alt5=1;
 842                                         }
 843                                         switch (alt5) {
 844                                                 case 1 :
 845                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:129:22: INT
 846                                                         {
 847                                                         mINT();
 848
 849                                                         }
 850                                                         break;
 851
 852                                         }
 853
 854                                         }
 855                                         break;
 856                                 case 2 :
 857                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:130:13: '..' INT
 858                                         {
 859                                         match("..");
 860
 861                                         mINT();
 862
 863                                         }
 864                                         break;
 865
 866                         }
 867                         state.type = _type;
 868                         state.channel = _channel;
 869                 }
 870                 finally {
 871                         // do for sure before leaving
 872                 }
 873         }
 874         // $ANTLR end "INT_RANGE"
 875
 876         // $ANTLR start "RANGE"
 877         public final void mRANGE() throws RecognitionException {
 878                 try {
 879                         int _type = RANGE;
 880                         int _channel = DEFAULT_TOKEN_CHANNEL;
 881                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:132:11: ( FLOAT '..' ( FLOAT | INT )? | '..' FLOAT | INT '..' FLOAT )
 882                         int alt8=3;
 883                         alt8 = dfa8.predict(input);
 884                         switch (alt8) {
 885                                 case 1 :
 886                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:132:13: FLOAT '..' ( FLOAT | INT )?
 887                                         {
 888                                         mFLOAT();
 889
 890                                         match("..");
 891
 892                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:132:24: ( FLOAT | INT )?
 893                                         int alt7=3;
 894                                         alt7 = dfa7.predict(input);
 895                                         switch (alt7) {
 896                                                 case 1 :
 897                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:132:25: FLOAT
 898                                                         {
 899                                                         mFLOAT();
 900
 901                                                         }
 902                                                         break;
 903                                                 case 2 :
 904                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:132:33: INT
 905                                                         {
 906                                                         mINT();
 907
 908                                                         }
 909                                                         break;
 910
 911                                         }
 912
 913                                         }
 914                                         break;
 915                                 case 2 :
 916                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:133:13: '..' FLOAT
 917                                         {
 918                                         match("..");
 919
 920                                         mFLOAT();
 921
 922                                         }
 923                                         break;
 924                                 case 3 :
 925                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:134:13: INT '..' FLOAT
 926                                         {
 927                                         mINT();
 928
 929                                         match("..");
 930
 931                                         mFLOAT();
 932
 933                                         }
 934                                         break;
 935
 936                         }
 937                         state.type = _type;
 938                         state.channel = _channel;
 939                 }
 940                 finally {
 941                         // do for sure before leaving
 942                 }
 943         }
 944         // $ANTLR end "RANGE"
 945
 946         // $ANTLR start "NEWLINE"
 947         public final void mNEWLINE() throws RecognitionException {
 948                 try {
 949                         int _type = NEWLINE;
 950                         int _channel = DEFAULT_TOKEN_CHANNEL;
 951                          int spaces = 0;
 952                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:139:5: ( '\\n' ( ' ' | '//' (~ ( '\\n' ) )* '\\n' | '/*' ( options {greedy=false; } : . )* '*/' | '\\r' | '\\n' )* )
 953                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:139:7: '\\n' ( ' ' | '//' (~ ( '\\n' ) )* '\\n' | '/*' ( options {greedy=false; } : . )* '*/' | '\\r' | '\\n' )*
 954                         {
 955                         match('\n');
 956                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:140:7: ( ' ' | '//' (~ ( '\\n' ) )* '\\n' | '/*' ( options {greedy=false; } : . )* '*/' | '\\r' | '\\n' )*
 957                         loop11:
 958                         while (true) {
 959                                 int alt11=6;
 960                                 switch ( input.LA(1) ) {
 961                                 case ' ':
 962                                         {
 963                                         alt11=1;
 964                                         }
 965                                         break;
 966                                 case '/':
 967                                         {
 968                                         int LA11_3 = input.LA(2);
 969                                         if ( (LA11_3=='/') ) {
 970                                                 alt11=2;
 971                                         }
 972                                         else if ( (LA11_3=='*') ) {
 973                                                 alt11=3;
 974                                         }
 975
 976                                         }
 977                                         break;
 978                                 case '\r':
 979                                         {
 980                                         alt11=4;
 981                                         }
 982                                         break;
 983                                 case '\n':
 984                                         {
 985                                         alt11=5;
 986                                         }
 987                                         break;
 988                                 }
 989                                 switch (alt11) {
 990                                 case 1 :
 991                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:140:9: ' '
 992                                         {
 993                                         match(' ');
 994                                          ++spaces;
 995                                         }
 996                                         break;
 997                                 case 2 :
 998                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:141:9: '//' (~ ( '\\n' ) )* '\\n'
 999                                         {
1000                                         match("//");
1001
1002                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:141:14: (~ ( '\\n' ) )*
1003                                         loop9:
1004                                         while (true) {
1005                                                 int alt9=2;
1006                                                 int LA9_0 = input.LA(1);
1007                                                 if ( ((LA9_0 >= '\u0000' && LA9_0 <= '\t')||(LA9_0 >= '\u000B' && LA9_0 <= '\uFFFF')) ) {
1008                                                         alt9=1;
1009                                                 }
1010
1011                                                 switch (alt9) {
1012                                                 case 1 :
1013                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:
1014                                                         {
1015                                                         if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '\t')||(input.LA(1) >= '\u000B' && input.LA(1) <= '\uFFFF') ) {
1016                                                                 input.consume();
1017                                                         }
1018                                                         else {
1019                                                                 MismatchedSetException mse = new MismatchedSetException(null,input);
1020                                                                 recover(mse);
1021                                                                 throw mse;
1022                                                         }
1023                                                         }
1024                                                         break;
1025
1026                                                 default :
1027                                                         break loop9;
1028                                                 }
1029                                         }
1030
1031                                         match('\n');
1032                                          spaces = 0;
1033                                         }
1034                                         break;
1035                                 case 3 :
1036                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:142:9: '/*' ( options {greedy=false; } : . )* '*/'
1037                                         {
1038                                         match("/*");
1039
1040                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:142:14: ( options {greedy=false; } : . )*
1041                                         loop10:
1042                                         while (true) {
1043                                                 int alt10=2;
1044                                                 int LA10_0 = input.LA(1);
1045                                                 if ( (LA10_0=='*') ) {
1046                                                         int LA10_1 = input.LA(2);
1047                                                         if ( (LA10_1=='/') ) {
1048                                                                 alt10=2;
1049                                                         }
1050                                                         else if ( ((LA10_1 >= '\u0000' && LA10_1 <= '.')||(LA10_1 >= '0' && LA10_1 <= '\uFFFF')) ) {
1051                                                                 alt10=1;
1052                                                         }
1053
1054                                                 }
1055                                                 else if ( ((LA10_0 >= '\u0000' && LA10_0 <= ')')||(LA10_0 >= '+' && LA10_0 <= '\uFFFF')) ) {
1056                                                         alt10=1;
1057                                                 }
1058
1059                                                 switch (alt10) {
1060                                                 case 1 :
1061                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:142:42: .
1062                                                         {
1063                                                         matchAny();
1064                                                         }
1065                                                         break;
1066
1067                                                 default :
1068                                                         break loop10;
1069                                                 }
1070                                         }
1071
1072                                         match("*/");
1073
1074                                         }
1075                                         break;
1076                                 case 4 :
1077                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:143:9: '\\r'
1078                                         {
1079                                         match('\r');
1080                                         }
1081                                         break;
1082                                 case 5 :
1083                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:144:9: '\\n'
1084                                         {
1085                                         match('\n');
1086                                          spaces = 0;
1087                                         }
1088                                         break;
1089
1090                                 default :
1091                                         break loop11;
1092                                 }
1093                         }
1094
1095
1096                                   int c = input.LA(1);
1097
1098                                   if(inParen > 0) {
1099                                       _channel = HIDDEN;
1100                                   }
1101                                   else if(c == EOF) {
1102                                       while(iStack.size() > 1) {
1103                                           iStack.removeAt(iStack.size()-1);
1104                                           state.type = DEDENT;
1105                                           emit();
1106                                       }
1107                                       _channel = HIDDEN;
1108                                       iStack.clear();
1109                                   }
1110                                   else {
1111                                       int stackTop = iStack.get(iStack.size()-1);
1112                                       if(spaces > stackTop) {
1113                                           iStack.add(spaces);
1114                                           _type = INDENT;
1115                                       }
1116                                       else if(spaces < stackTop) {
1117                                           while(spaces < iStack.get(iStack.size()-1)) {
1118                                               iStack.removeAt(iStack.size()-1);
1119                                               state.type = DEDENT;
1120                                               emit();
1121                                           }
1122                                           state.type = NEWLINE;
1123                                           emit();
1124                                           // TODO check that spaces == iStack.get(iStack.size()-1)
1125                                       }
1126                                   }
1127
1128                         }
1129
1130                         state.type = _type;
1131                         state.channel = _channel;
1132                 }
1133                 finally {
1134                         // do for sure before leaving
1135                 }
1136         }
1137         // $ANTLR end "NEWLINE"
1138
1139         // $ANTLR start "INDENT"
1140         public final void mINDENT() throws RecognitionException {
1141                 try {
1142                         int _type = INDENT;
1143                         int _channel = DEFAULT_TOKEN_CHANNEL;
1144                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:181:7: ({...}? => 'INDENT' )
1145                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:181:9: {...}? => 'INDENT'
1146                         {
1147                         if ( !(( false )) ) {
1148                                 throw new FailedPredicateException(input, "INDENT", " false ");
1149                         }
1150                         match("INDENT");
1151
1152                         }
1153
1154                         state.type = _type;
1155                         state.channel = _channel;
1156                 }
1157                 finally {
1158                         // do for sure before leaving
1159                 }
1160         }
1161         // $ANTLR end "INDENT"
1162
1163         // $ANTLR start "DEDENT"
1164         public final void mDEDENT() throws RecognitionException {
1165                 try {
1166                         int _type = DEDENT;
1167                         int _channel = DEFAULT_TOKEN_CHANNEL;
1168                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:182:7: ({...}? => 'DEDENT' )
1169                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:182:9: {...}? => 'DEDENT'
1170                         {
1171                         if ( !(( false )) ) {
1172                                 throw new FailedPredicateException(input, "DEDENT", " false ");
1173                         }
1174                         match("DEDENT");
1175
1176                         }
1177
1178                         state.type = _type;
1179                         state.channel = _channel;
1180                 }
1181                 finally {
1182                         // do for sure before leaving
1183                 }
1184         }
1185         // $ANTLR end "DEDENT"
1186
1187         // $ANTLR start "INT"
1188         public final void mINT() throws RecognitionException {
1189                 try {
1190                         int _type = INT;
1191                         int _channel = DEFAULT_TOKEN_CHANNEL;
1192                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:184:5: ( ( '-' )? ( '0' .. '9' )+ )
1193                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:184:7: ( '-' )? ( '0' .. '9' )+
1194                         {
1195                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:184:7: ( '-' )?
1196                         int alt12=2;
1197                         int LA12_0 = input.LA(1);
1198                         if ( (LA12_0=='-') ) {
1199                                 alt12=1;
1200                         }
1201                         switch (alt12) {
1202                                 case 1 :
1203                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:184:7: '-'
1204                                         {
1205                                         match('-');
1206                                         }
1207                                         break;
1208
1209                         }
1210
1211                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:184:12: ( '0' .. '9' )+
1212                         int cnt13=0;
1213                         loop13:
1214                         while (true) {
1215                                 int alt13=2;
1216                                 int LA13_0 = input.LA(1);
1217                                 if ( ((LA13_0 >= '0' && LA13_0 <= '9')) ) {
1218                                         alt13=1;
1219                                 }
1220
1221                                 switch (alt13) {
1222                                 case 1 :
1223                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:
1224                                         {
1225                                         if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
1226                                                 input.consume();
1227                                         }
1228                                         else {
1229                                                 MismatchedSetException mse = new MismatchedSetException(null,input);
1230                                                 recover(mse);
1231                                                 throw mse;
1232                                         }
1233                                         }
1234                                         break;
1235
1236                                 default :
1237                                         if ( cnt13 >= 1 ) break loop13;
1238                                         EarlyExitException eee = new EarlyExitException(13, input);
1239                                         throw eee;
1240                                 }
1241                                 cnt13++;
1242                         }
1243
1244                         }
1245
1246                         state.type = _type;
1247                         state.channel = _channel;
1248                 }
1249                 finally {
1250                         // do for sure before leaving
1251                 }
1252         }
1253         // $ANTLR end "INT"
1254
1255         // $ANTLR start "FLOAT"
1256         public final void mFLOAT() throws RecognitionException {
1257                 try {
1258                         int _type = FLOAT;
1259                         int _channel = DEFAULT_TOKEN_CHANNEL;
1260                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:188:5: ( ( '-' )? ( ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( EXPONENT )? | ( '0' .. '9' )+ EXPONENT ) )
1261                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:188:7: ( '-' )? ( ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( EXPONENT )? | ( '0' .. '9' )+ EXPONENT )
1262                         {
1263                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:188:7: ( '-' )?
1264                         int alt14=2;
1265                         int LA14_0 = input.LA(1);
1266                         if ( (LA14_0=='-') ) {
1267                                 alt14=1;
1268                         }
1269                         switch (alt14) {
1270                                 case 1 :
1271                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:188:7: '-'
1272                                         {
1273                                         match('-');
1274                                         }
1275                                         break;
1276
1277                         }
1278
1279                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:189:5: ( ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( EXPONENT )? | ( '0' .. '9' )+ EXPONENT )
1280                         int alt19=2;
1281                         alt19 = dfa19.predict(input);
1282                         switch (alt19) {
1283                                 case 1 :
1284                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:189:7: ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( EXPONENT )?
1285                                         {
1286                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:189:7: ( '0' .. '9' )+
1287                                         int cnt15=0;
1288                                         loop15:
1289                                         while (true) {
1290                                                 int alt15=2;
1291                                                 int LA15_0 = input.LA(1);
1292                                                 if ( ((LA15_0 >= '0' && LA15_0 <= '9')) ) {
1293                                                         alt15=1;
1294                                                 }
1295
1296                                                 switch (alt15) {
1297                                                 case 1 :
1298                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:
1299                                                         {
1300                                                         if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
1301                                                                 input.consume();
1302                                                         }
1303                                                         else {
1304                                                                 MismatchedSetException mse = new MismatchedSetException(null,input);
1305                                                                 recover(mse);
1306                                                                 throw mse;
1307                                                         }
1308                                                         }
1309                                                         break;
1310
1311                                                 default :
1312                                                         if ( cnt15 >= 1 ) break loop15;
1313                                                         EarlyExitException eee = new EarlyExitException(15, input);
1314                                                         throw eee;
1315                                                 }
1316                                                 cnt15++;
1317                                         }
1318
1319                                         match('.');
1320                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:189:23: ( '0' .. '9' )*
1321                                         loop16:
1322                                         while (true) {
1323                                                 int alt16=2;
1324                                                 int LA16_0 = input.LA(1);
1325                                                 if ( ((LA16_0 >= '0' && LA16_0 <= '9')) ) {
1326                                                         alt16=1;
1327                                                 }
1328
1329                                                 switch (alt16) {
1330                                                 case 1 :
1331                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:
1332                                                         {
1333                                                         if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
1334                                                                 input.consume();
1335                                                         }
1336                                                         else {
1337                                                                 MismatchedSetException mse = new MismatchedSetException(null,input);
1338                                                                 recover(mse);
1339                                                                 throw mse;
1340                                                         }
1341                                                         }
1342                                                         break;
1343
1344                                                 default :
1345                                                         break loop16;
1346                                                 }
1347                                         }
1348
1349                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:189:35: ( EXPONENT )?
1350                                         int alt17=2;
1351                                         int LA17_0 = input.LA(1);
1352                                         if ( (LA17_0=='E'||LA17_0=='e') ) {
1353                                                 alt17=1;
1354                                         }
1355                                         switch (alt17) {
1356                                                 case 1 :
1357                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:189:35: EXPONENT
1358                                                         {
1359                                                         mEXPONENT();
1360
1361                                                         }
1362                                                         break;
1363
1364                                         }
1365
1366                                         }
1367                                         break;
1368                                 case 2 :
1369                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:190:7: ( '0' .. '9' )+ EXPONENT
1370                                         {
1371                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:190:7: ( '0' .. '9' )+
1372                                         int cnt18=0;
1373                                         loop18:
1374                                         while (true) {
1375                                                 int alt18=2;
1376                                                 int LA18_0 = input.LA(1);
1377                                                 if ( ((LA18_0 >= '0' && LA18_0 <= '9')) ) {
1378                                                         alt18=1;
1379                                                 }
1380
1381                                                 switch (alt18) {
1382                                                 case 1 :
1383                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:
1384                                                         {
1385                                                         if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
1386                                                                 input.consume();
1387                                                         }
1388                                                         else {
1389                                                                 MismatchedSetException mse = new MismatchedSetException(null,input);
1390                                                                 recover(mse);
1391                                                                 throw mse;
1392                                                         }
1393                                                         }
1394                                                         break;
1395
1396                                                 default :
1397                                                         if ( cnt18 >= 1 ) break loop18;
1398                                                         EarlyExitException eee = new EarlyExitException(18, input);
1399                                                         throw eee;
1400                                                 }
1401                                                 cnt18++;
1402                                         }
1403
1404                                         mEXPONENT();
1405
1406                                         }
1407                                         break;
1408
1409                         }
1410
1411                         }
1412
1413                         state.type = _type;
1414                         state.channel = _channel;
1415                 }
1416                 finally {
1417                         // do for sure before leaving
1418                 }
1419         }
1420         // $ANTLR end "FLOAT"
1421
1422         // $ANTLR start "STRING"
1423         public final void mSTRING() throws RecognitionException {
1424                 try {
1425                         int _type = STRING;
1426                         int _channel = DEFAULT_TOKEN_CHANNEL;
1427                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:195:5: ( '\"' ( ESC_SEQ |~ ( '\\\\' | '\"' ) )* '\"' | '\"\"\"' (~ ( '\"' ) | '\"' ~ ( '\"' ) | '\"\"' ~ ( '\"' ) )* '\"\"\"' )
1428                         int alt22=2;
1429                         int LA22_0 = input.LA(1);
1430                         if ( (LA22_0=='\"') ) {
1431                                 int LA22_1 = input.LA(2);
1432                                 if ( (LA22_1=='\"') ) {
1433                                         int LA22_2 = input.LA(3);
1434                                         if ( (LA22_2=='\"') ) {
1435                                                 alt22=2;
1436                                         }
1437
1438                                         else {
1439                                                 alt22=1;
1440                                         }
1441
1442                                 }
1443                                 else if ( ((LA22_1 >= '\u0000' && LA22_1 <= '!')||(LA22_1 >= '#' && LA22_1 <= '\uFFFF')) ) {
1444                                         alt22=1;
1445                                 }
1446
1447                                 else {
1448                                         int nvaeMark = input.mark();
1449                                         try {
1450                                                 input.consume();
1451                                                 NoViableAltException nvae =
1452                                                         new NoViableAltException("", 22, 1, input);
1453                                                 throw nvae;
1454                                         } finally {
1455                                                 input.rewind(nvaeMark);
1456                                         }
1457                                 }
1458
1459                         }
1460
1461                         else {
1462                                 NoViableAltException nvae =
1463                                         new NoViableAltException("", 22, 0, input);
1464                                 throw nvae;
1465                         }
1466
1467                         switch (alt22) {
1468                                 case 1 :
1469                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:195:8: '\"' ( ESC_SEQ |~ ( '\\\\' | '\"' ) )* '\"'
1470                                         {
1471                                         match('\"');
1472                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:195:12: ( ESC_SEQ |~ ( '\\\\' | '\"' ) )*
1473                                         loop20:
1474                                         while (true) {
1475                                                 int alt20=3;
1476                                                 int LA20_0 = input.LA(1);
1477                                                 if ( (LA20_0=='\\') ) {
1478                                                         alt20=1;
1479                                                 }
1480                                                 else if ( ((LA20_0 >= '\u0000' && LA20_0 <= '!')||(LA20_0 >= '#' && LA20_0 <= '[')||(LA20_0 >= ']' && LA20_0 <= '\uFFFF')) ) {
1481                                                         alt20=2;
1482                                                 }
1483
1484                                                 switch (alt20) {
1485                                                 case 1 :
1486                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:195:14: ESC_SEQ
1487                                                         {
1488                                                         mESC_SEQ();
1489
1490                                                         }
1491                                                         break;
1492                                                 case 2 :
1493                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:195:24: ~ ( '\\\\' | '\"' )
1494                                                         {
1495                                                         if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '!')||(input.LA(1) >= '#' && input.LA(1) <= '[')||(input.LA(1) >= ']' && input.LA(1) <= '\uFFFF') ) {
1496                                                                 input.consume();
1497                                                         }
1498                                                         else {
1499                                                                 MismatchedSetException mse = new MismatchedSetException(null,input);
1500                                                                 recover(mse);
1501                                                                 throw mse;
1502                                                         }
1503                                                         }
1504                                                         break;
1505
1506                                                 default :
1507                                                         break loop20;
1508                                                 }
1509                                         }
1510
1511                                         match('\"');
1512                                         }
1513                                         break;
1514                                 case 2 :
1515                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:196:8: '\"\"\"' (~ ( '\"' ) | '\"' ~ ( '\"' ) | '\"\"' ~ ( '\"' ) )* '\"\"\"'
1516                                         {
1517                                         match("\"\"\"");
1518
1519                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:196:14: (~ ( '\"' ) | '\"' ~ ( '\"' ) | '\"\"' ~ ( '\"' ) )*
1520                                         loop21:
1521                                         while (true) {
1522                                                 int alt21=4;
1523                                                 int LA21_0 = input.LA(1);
1524                                                 if ( (LA21_0=='\"') ) {
1525                                                         int LA21_1 = input.LA(2);
1526                                                         if ( (LA21_1=='\"') ) {
1527                                                                 int LA21_3 = input.LA(3);
1528                                                                 if ( ((LA21_3 >= '\u0000' && LA21_3 <= '!')||(LA21_3 >= '#' && LA21_3 <= '\uFFFF')) ) {
1529                                                                         alt21=3;
1530                                                                 }
1531
1532                                                         }
1533                                                         else if ( ((LA21_1 >= '\u0000' && LA21_1 <= '!')||(LA21_1 >= '#' && LA21_1 <= '\uFFFF')) ) {
1534                                                                 alt21=2;
1535                                                         }
1536
1537                                                 }
1538                                                 else if ( ((LA21_0 >= '\u0000' && LA21_0 <= '!')||(LA21_0 >= '#' && LA21_0 <= '\uFFFF')) ) {
1539                                                         alt21=1;
1540                                                 }
1541
1542                                                 switch (alt21) {
1543                                                 case 1 :
1544                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:196:16: ~ ( '\"' )
1545                                                         {
1546                                                         if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '!')||(input.LA(1) >= '#' && input.LA(1) <= '\uFFFF') ) {
1547                                                                 input.consume();
1548                                                         }
1549                                                         else {
1550                                                                 MismatchedSetException mse = new MismatchedSetException(null,input);
1551                                                                 recover(mse);
1552                                                                 throw mse;
1553                                                         }
1554                                                         }
1555                                                         break;
1556                                                 case 2 :
1557                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:196:25: '\"' ~ ( '\"' )
1558                                                         {
1559                                                         match('\"');
1560                                                         if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '!')||(input.LA(1) >= '#' && input.LA(1) <= '\uFFFF') ) {
1561                                                                 input.consume();
1562                                                         }
1563                                                         else {
1564                                                                 MismatchedSetException mse = new MismatchedSetException(null,input);
1565                                                                 recover(mse);
1566                                                                 throw mse;
1567                                                         }
1568                                                         }
1569                                                         break;
1570                                                 case 3 :
1571                                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:196:38: '\"\"' ~ ( '\"' )
1572                                                         {
1573                                                         match("\"\"");
1574
1575                                                         if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '!')||(input.LA(1) >= '#' && input.LA(1) <= '\uFFFF') ) {
1576                                                                 input.consume();
1577                                                         }
1578                                                         else {
1579                                                                 MismatchedSetException mse = new MismatchedSetException(null,input);
1580                                                                 recover(mse);
1581                                                                 throw mse;
1582                                                         }
1583                                                         }
1584                                                         break;
1585
1586                                                 default :
1587                                                         break loop21;
1588                                                 }
1589                                         }
1590
1591                                         match("\"\"\"");
1592
1593                                         }
1594                                         break;
1595
1596                         }
1597                         state.type = _type;
1598                         state.channel = _channel;
1599                 }
1600                 finally {
1601                         // do for sure before leaving
1602                 }
1603         }
1604         // $ANTLR end "STRING"
1605
1606         // $ANTLR start "URI"
1607         public final void mURI() throws RecognitionException {
1608                 try {
1609                         int _type = URI;
1610                         int _channel = DEFAULT_TOKEN_CHANNEL;
1611                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:200:5: ( '<http:' (~ ( '>' ) )* '>' )
1612                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:200:8: '<http:' (~ ( '>' ) )* '>'
1613                         {
1614                         match("<http:");
1615
1616                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:200:17: (~ ( '>' ) )*
1617                         loop23:
1618                         while (true) {
1619                                 int alt23=2;
1620                                 int LA23_0 = input.LA(1);
1621                                 if ( ((LA23_0 >= '\u0000' && LA23_0 <= '=')||(LA23_0 >= '?' && LA23_0 <= '\uFFFF')) ) {
1622                                         alt23=1;
1623                                 }
1624
1625                                 switch (alt23) {
1626                                 case 1 :
1627                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:
1628                                         {
1629                                         if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '=')||(input.LA(1) >= '?' && input.LA(1) <= '\uFFFF') ) {
1630                                                 input.consume();
1631                                         }
1632                                         else {
1633                                                 MismatchedSetException mse = new MismatchedSetException(null,input);
1634                                                 recover(mse);
1635                                                 throw mse;
1636                                         }
1637                                         }
1638                                         break;
1639
1640                                 default :
1641                                         break loop23;
1642                                 }
1643                         }
1644
1645                         match('>');
1646                         }
1647
1648                         state.type = _type;
1649                         state.channel = _channel;
1650                 }
1651                 finally {
1652                         // do for sure before leaving
1653                 }
1654         }
1655         // $ANTLR end "URI"
1656
1657         // $ANTLR start "EXPONENT"
1658         public final void mEXPONENT() throws RecognitionException {
1659                 try {
1660                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:205:10: ( ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+ )
1661                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:205:12: ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+
1662                         {
1663                         if ( input.LA(1)=='E'||input.LA(1)=='e' ) {
1664                                 input.consume();
1665                         }
1666                         else {
1667                                 MismatchedSetException mse = new MismatchedSetException(null,input);
1668                                 recover(mse);
1669                                 throw mse;
1670                         }
1671                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:205:22: ( '+' | '-' )?
1672                         int alt24=2;
1673                         int LA24_0 = input.LA(1);
1674                         if ( (LA24_0=='+'||LA24_0=='-') ) {
1675                                 alt24=1;
1676                         }
1677                         switch (alt24) {
1678                                 case 1 :
1679                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:
1680                                         {
1681                                         if ( input.LA(1)=='+'||input.LA(1)=='-' ) {
1682                                                 input.consume();
1683                                         }
1684                                         else {
1685                                                 MismatchedSetException mse = new MismatchedSetException(null,input);
1686                                                 recover(mse);
1687                                                 throw mse;
1688                                         }
1689                                         }
1690                                         break;
1691
1692                         }
1693
1694                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:205:33: ( '0' .. '9' )+
1695                         int cnt25=0;
1696                         loop25:
1697                         while (true) {
1698                                 int alt25=2;
1699                                 int LA25_0 = input.LA(1);
1700                                 if ( ((LA25_0 >= '0' && LA25_0 <= '9')) ) {
1701                                         alt25=1;
1702                                 }
1703
1704                                 switch (alt25) {
1705                                 case 1 :
1706                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:
1707                                         {
1708                                         if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
1709                                                 input.consume();
1710                                         }
1711                                         else {
1712                                                 MismatchedSetException mse = new MismatchedSetException(null,input);
1713                                                 recover(mse);
1714                                                 throw mse;
1715                                         }
1716                                         }
1717                                         break;
1718
1719                                 default :
1720                                         if ( cnt25 >= 1 ) break loop25;
1721                                         EarlyExitException eee = new EarlyExitException(25, input);
1722                                         throw eee;
1723                                 }
1724                                 cnt25++;
1725                         }
1726
1727                         }
1728
1729                 }
1730                 finally {
1731                         // do for sure before leaving
1732                 }
1733         }
1734         // $ANTLR end "EXPONENT"
1735
1736         // $ANTLR start "HEX_DIGIT"
1737         public final void mHEX_DIGIT() throws RecognitionException {
1738                 try {
1739                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:208:11: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )
1740                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:
1741                         {
1742                         if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'F')||(input.LA(1) >= 'a' && input.LA(1) <= 'f') ) {
1743                                 input.consume();
1744                         }
1745                         else {
1746                                 MismatchedSetException mse = new MismatchedSetException(null,input);
1747                                 recover(mse);
1748                                 throw mse;
1749                         }
1750                         }
1751
1752                 }
1753                 finally {
1754                         // do for sure before leaving
1755                 }
1756         }
1757         // $ANTLR end "HEX_DIGIT"
1758
1759         // $ANTLR start "ESC_SEQ"
1760         public final void mESC_SEQ() throws RecognitionException {
1761                 try {
1762                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:212:5: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | UNICODE_ESC )
1763                         int alt26=2;
1764                         int LA26_0 = input.LA(1);
1765                         if ( (LA26_0=='\\') ) {
1766                                 int LA26_1 = input.LA(2);
1767                                 if ( (LA26_1=='\"'||LA26_1=='\''||LA26_1=='\\'||LA26_1=='b'||LA26_1=='f'||LA26_1=='n'||LA26_1=='r'||LA26_1=='t') ) {
1768                                         alt26=1;
1769                                 }
1770                                 else if ( (LA26_1=='u') ) {
1771                                         alt26=2;
1772                                 }
1773
1774                                 else {
1775                                         int nvaeMark = input.mark();
1776                                         try {
1777                                                 input.consume();
1778                                                 NoViableAltException nvae =
1779                                                         new NoViableAltException("", 26, 1, input);
1780                                                 throw nvae;
1781                                         } finally {
1782                                                 input.rewind(nvaeMark);
1783                                         }
1784                                 }
1785
1786                         }
1787
1788                         else {
1789                                 NoViableAltException nvae =
1790                                         new NoViableAltException("", 26, 0, input);
1791                                 throw nvae;
1792                         }
1793
1794                         switch (alt26) {
1795                                 case 1 :
1796                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:212:9: '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' )
1797                                         {
1798                                         match('\\');
1799                                         if ( input.LA(1)=='\"'||input.LA(1)=='\''||input.LA(1)=='\\'||input.LA(1)=='b'||input.LA(1)=='f'||input.LA(1)=='n'||input.LA(1)=='r'||input.LA(1)=='t' ) {
1800                                                 input.consume();
1801                                         }
1802                                         else {
1803                                                 MismatchedSetException mse = new MismatchedSetException(null,input);
1804                                                 recover(mse);
1805                                                 throw mse;
1806                                         }
1807                                         }
1808                                         break;
1809                                 case 2 :
1810                                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:213:9: UNICODE_ESC
1811                                         {
1812                                         mUNICODE_ESC();
1813
1814                                         }
1815                                         break;
1816
1817                         }
1818                 }
1819                 finally {
1820                         // do for sure before leaving
1821                 }
1822         }
1823         // $ANTLR end "ESC_SEQ"
1824
1825         // $ANTLR start "UNICODE_ESC"
1826         public final void mUNICODE_ESC() throws RecognitionException {
1827                 try {
1828                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:218:5: ( '\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT )
1829                         // src/org/simantics/graph/compiler/internal/parsing/Graph.g:218:9: '\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
1830                         {
1831                         match('\\');
1832                         match('u');
1833                         mHEX_DIGIT();
1834
1835                         mHEX_DIGIT();
1836
1837                         mHEX_DIGIT();
1838
1839                         mHEX_DIGIT();
1840
1841                         }
1842
1843                 }
1844                 finally {
1845                         // do for sure before leaving
1846                 }
1847         }
1848         // $ANTLR end "UNICODE_ESC"
1849
1850         @Override
1851         public void mTokens() throws RecognitionException {
1852                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:8: ( T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | ID | COMMENT | WS | LPAREN | RPAREN | LBRACKET | RBRACKET | LCURLY | RCURLY | INT_RANGE | RANGE | NEWLINE | INDENT | DEDENT | INT | FLOAT | STRING | URI )
1853                 int alt27=34;
1854                 alt27 = dfa27.predict(input);
1855                 switch (alt27) {
1856                         case 1 :
1857                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:10: T__65
1858                                 {
1859                                 mT__65();
1860
1861                                 }
1862                                 break;
1863                         case 2 :
1864                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:16: T__66
1865                                 {
1866                                 mT__66();
1867
1868                                 }
1869                                 break;
1870                         case 3 :
1871                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:22: T__67
1872                                 {
1873                                 mT__67();
1874
1875                                 }
1876                                 break;
1877                         case 4 :
1878                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:28: T__68
1879                                 {
1880                                 mT__68();
1881
1882                                 }
1883                                 break;
1884                         case 5 :
1885                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:34: T__69
1886                                 {
1887                                 mT__69();
1888
1889                                 }
1890                                 break;
1891                         case 6 :
1892                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:40: T__70
1893                                 {
1894                                 mT__70();
1895
1896                                 }
1897                                 break;
1898                         case 7 :
1899                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:46: T__71
1900                                 {
1901                                 mT__71();
1902
1903                                 }
1904                                 break;
1905                         case 8 :
1906                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:52: T__72
1907                                 {
1908                                 mT__72();
1909
1910                                 }
1911                                 break;
1912                         case 9 :
1913                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:58: T__73
1914                                 {
1915                                 mT__73();
1916
1917                                 }
1918                                 break;
1919                         case 10 :
1920                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:64: T__74
1921                                 {
1922                                 mT__74();
1923
1924                                 }
1925                                 break;
1926                         case 11 :
1927                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:70: T__75
1928                                 {
1929                                 mT__75();
1930
1931                                 }
1932                                 break;
1933                         case 12 :
1934                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:76: T__76
1935                                 {
1936                                 mT__76();
1937
1938                                 }
1939                                 break;
1940                         case 13 :
1941                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:82: T__77
1942                                 {
1943                                 mT__77();
1944
1945                                 }
1946                                 break;
1947                         case 14 :
1948                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:88: T__78
1949                                 {
1950                                 mT__78();
1951
1952                                 }
1953                                 break;
1954                         case 15 :
1955                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:94: T__79
1956                                 {
1957                                 mT__79();
1958
1959                                 }
1960                                 break;
1961                         case 16 :
1962                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:100: T__80
1963                                 {
1964                                 mT__80();
1965
1966                                 }
1967                                 break;
1968                         case 17 :
1969                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:106: ID
1970                                 {
1971                                 mID();
1972
1973                                 }
1974                                 break;
1975                         case 18 :
1976                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:109: COMMENT
1977                                 {
1978                                 mCOMMENT();
1979
1980                                 }
1981                                 break;
1982                         case 19 :
1983                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:117: WS
1984                                 {
1985                                 mWS();
1986
1987                                 }
1988                                 break;
1989                         case 20 :
1990                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:120: LPAREN
1991                                 {
1992                                 mLPAREN();
1993
1994                                 }
1995                                 break;
1996                         case 21 :
1997                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:127: RPAREN
1998                                 {
1999                                 mRPAREN();
2000
2001                                 }
2002                                 break;
2003                         case 22 :
2004                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:134: LBRACKET
2005                                 {
2006                                 mLBRACKET();
2007
2008                                 }
2009                                 break;
2010                         case 23 :
2011                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:143: RBRACKET
2012                                 {
2013                                 mRBRACKET();
2014
2015                                 }
2016                                 break;
2017                         case 24 :
2018                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:152: LCURLY
2019                                 {
2020                                 mLCURLY();
2021
2022                                 }
2023                                 break;
2024                         case 25 :
2025                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:159: RCURLY
2026                                 {
2027                                 mRCURLY();
2028
2029                                 }
2030                                 break;
2031                         case 26 :
2032                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:166: INT_RANGE
2033                                 {
2034                                 mINT_RANGE();
2035
2036                                 }
2037                                 break;
2038                         case 27 :
2039                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:176: RANGE
2040                                 {
2041                                 mRANGE();
2042
2043                                 }
2044                                 break;
2045                         case 28 :
2046                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:182: NEWLINE
2047                                 {
2048                                 mNEWLINE();
2049
2050                                 }
2051                                 break;
2052                         case 29 :
2053                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:190: INDENT
2054                                 {
2055                                 mINDENT();
2056
2057                                 }
2058                                 break;
2059                         case 30 :
2060                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:197: DEDENT
2061                                 {
2062                                 mDEDENT();
2063
2064                                 }
2065                                 break;
2066                         case 31 :
2067                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:204: INT
2068                                 {
2069                                 mINT();
2070
2071                                 }
2072                                 break;
2073                         case 32 :
2074                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:208: FLOAT
2075                                 {
2076                                 mFLOAT();
2077
2078                                 }
2079                                 break;
2080                         case 33 :
2081                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:214: STRING
2082                                 {
2083                                 mSTRING();
2084
2085                                 }
2086                                 break;
2087                         case 34 :
2088                                 // src/org/simantics/graph/compiler/internal/parsing/Graph.g:1:221: URI
2089                                 {
2090                                 mURI();
2091
2092                                 }
2093                                 break;
2094
2095                 }
2096         }
2097
2098
2099         protected DFA8 dfa8 = new DFA8(this);
2100         protected DFA7 dfa7 = new DFA7(this);
2101         protected DFA19 dfa19 = new DFA19(this);
2102         protected DFA27 dfa27 = new DFA27(this);
2103         static final String DFA8_eotS =
2104                 "\10\uffff";
2105         static final String DFA8_eofS =
2106                 "\10\uffff";
2107         static final String DFA8_minS =
2108                 "\1\55\1\60\1\56\1\uffff\1\56\1\uffff\1\55\1\uffff";
2109         static final String DFA8_maxS =
2110                 "\2\71\1\145\1\uffff\1\145\1\uffff\1\71\1\uffff";
2111         static final String DFA8_acceptS =
2112                 "\3\uffff\1\2\1\uffff\1\1\1\uffff\1\3";
2113         static final String DFA8_specialS =
2114                 "\10\uffff}>";
2115         static final String[] DFA8_transitionS = {
2116                         "\1\1\1\3\1\uffff\12\2",
2117                         "\12\2",
2118                         "\1\4\1\uffff\12\2\13\uffff\1\5\37\uffff\1\5",
2119                         "",
2120                         "\1\6\1\uffff\12\5\13\uffff\1\5\37\uffff\1\5",
2121                         "",
2122                         "\1\7\1\5\1\uffff\12\7",
2123                         ""
2124         };
2125
2126         static final short[] DFA8_eot = DFA.unpackEncodedString(DFA8_eotS);
2127         static final short[] DFA8_eof = DFA.unpackEncodedString(DFA8_eofS);
2128         static final char[] DFA8_min = DFA.unpackEncodedStringToUnsignedChars(DFA8_minS);
2129         static final char[] DFA8_max = DFA.unpackEncodedStringToUnsignedChars(DFA8_maxS);
2130         static final short[] DFA8_accept = DFA.unpackEncodedString(DFA8_acceptS);
2131         static final short[] DFA8_special = DFA.unpackEncodedString(DFA8_specialS);
2132         static final short[][] DFA8_transition;
2133
2134         static {
2135                 int numStates = DFA8_transitionS.length;
2136                 DFA8_transition = new short[numStates][];
2137                 for (int i=0; i<numStates; i++) {
2138                         DFA8_transition[i] = DFA.unpackEncodedString(DFA8_transitionS[i]);
2139                 }
2140         }
2141
2142         protected class DFA8 extends DFA {
2143
2144                 public DFA8(BaseRecognizer recognizer) {
2145                         this.recognizer = recognizer;
2146                         this.decisionNumber = 8;
2147                         this.eot = DFA8_eot;
2148                         this.eof = DFA8_eof;
2149                         this.min = DFA8_min;
2150                         this.max = DFA8_max;
2151                         this.accept = DFA8_accept;
2152                         this.special = DFA8_special;
2153                         this.transition = DFA8_transition;
2154                 }
2155                 @Override
2156                 public String getDescription() {
2157                         return "132:1: RANGE : ( FLOAT '..' ( FLOAT | INT )? | '..' FLOAT | INT '..' FLOAT );";
2158                 }
2159         }
2160
2161         static final String DFA7_eotS =
2162                 "\1\3\1\uffff\1\5\3\uffff";
2163         static final String DFA7_eofS =
2164                 "\6\uffff";
2165         static final String DFA7_minS =
2166                 "\1\55\1\60\1\56\3\uffff";
2167         static final String DFA7_maxS =
2168                 "\2\71\1\145\3\uffff";
2169         static final String DFA7_acceptS =
2170                 "\3\uffff\1\3\1\1\1\2";
2171         static final String DFA7_specialS =
2172                 "\6\uffff}>";
2173         static final String[] DFA7_transitionS = {
2174                         "\1\1\2\uffff\12\2",
2175                         "\12\2",
2176                         "\1\4\1\uffff\12\2\13\uffff\1\4\37\uffff\1\4",
2177                         "",
2178                         "",
2179                         ""
2180         };
2181
2182         static final short[] DFA7_eot = DFA.unpackEncodedString(DFA7_eotS);
2183         static final short[] DFA7_eof = DFA.unpackEncodedString(DFA7_eofS);
2184         static final char[] DFA7_min = DFA.unpackEncodedStringToUnsignedChars(DFA7_minS);
2185         static final char[] DFA7_max = DFA.unpackEncodedStringToUnsignedChars(DFA7_maxS);
2186         static final short[] DFA7_accept = DFA.unpackEncodedString(DFA7_acceptS);
2187         static final short[] DFA7_special = DFA.unpackEncodedString(DFA7_specialS);
2188         static final short[][] DFA7_transition;
2189
2190         static {
2191                 int numStates = DFA7_transitionS.length;
2192                 DFA7_transition = new short[numStates][];
2193                 for (int i=0; i<numStates; i++) {
2194                         DFA7_transition[i] = DFA.unpackEncodedString(DFA7_transitionS[i]);
2195                 }
2196         }
2197
2198         protected class DFA7 extends DFA {
2199
2200                 public DFA7(BaseRecognizer recognizer) {
2201                         this.recognizer = recognizer;
2202                         this.decisionNumber = 7;
2203                         this.eot = DFA7_eot;
2204                         this.eof = DFA7_eof;
2205                         this.min = DFA7_min;
2206                         this.max = DFA7_max;
2207                         this.accept = DFA7_accept;
2208                         this.special = DFA7_special;
2209                         this.transition = DFA7_transition;
2210                 }
2211                 @Override
2212                 public String getDescription() {
2213                         return "132:24: ( FLOAT | INT )?";
2214                 }
2215         }
2216
2217         static final String DFA19_eotS =
2218                 "\4\uffff";
2219         static final String DFA19_eofS =
2220                 "\4\uffff";
2221         static final String DFA19_minS =
2222                 "\1\60\1\56\2\uffff";
2223         static final String DFA19_maxS =
2224                 "\1\71\1\145\2\uffff";
2225         static final String DFA19_acceptS =
2226                 "\2\uffff\1\1\1\2";
2227         static final String DFA19_specialS =
2228                 "\4\uffff}>";
2229         static final String[] DFA19_transitionS = {
2230                         "\12\1",
2231                         "\1\2\1\uffff\12\1\13\uffff\1\3\37\uffff\1\3",
2232                         "",
2233                         ""
2234         };
2235
2236         static final short[] DFA19_eot = DFA.unpackEncodedString(DFA19_eotS);
2237         static final short[] DFA19_eof = DFA.unpackEncodedString(DFA19_eofS);
2238         static final char[] DFA19_min = DFA.unpackEncodedStringToUnsignedChars(DFA19_minS);
2239         static final char[] DFA19_max = DFA.unpackEncodedStringToUnsignedChars(DFA19_maxS);
2240         static final short[] DFA19_accept = DFA.unpackEncodedString(DFA19_acceptS);
2241         static final short[] DFA19_special = DFA.unpackEncodedString(DFA19_specialS);
2242         static final short[][] DFA19_transition;
2243
2244         static {
2245                 int numStates = DFA19_transitionS.length;
2246                 DFA19_transition = new short[numStates][];
2247                 for (int i=0; i<numStates; i++) {
2248                         DFA19_transition[i] = DFA.unpackEncodedString(DFA19_transitionS[i]);
2249                 }
2250         }
2251
2252         protected class DFA19 extends DFA {
2253
2254                 public DFA19(BaseRecognizer recognizer) {
2255                         this.recognizer = recognizer;
2256                         this.decisionNumber = 19;
2257                         this.eot = DFA19_eot;
2258                         this.eof = DFA19_eof;
2259                         this.min = DFA19_min;
2260                         this.max = DFA19_max;
2261                         this.accept = DFA19_accept;
2262                         this.special = DFA19_special;
2263                         this.transition = DFA19_transition;
2264                 }
2265                 @Override
2266                 public String getDescription() {
2267                         return "189:5: ( ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( EXPONENT )? | ( '0' .. '9' )+ EXPONENT )";
2268                 }
2269         }
2270
2271         static final String DFA27_eotS =
2272                 "\5\uffff\1\36\2\uffff\1\44\2\uffff\2\32\1\uffff\1\32\10\uffff\1\50\1\uffff"+
2273                 "\1\32\13\uffff\3\32\1\uffff\1\64\1\uffff\1\32\1\uffff\1\70\3\32\1\70\1"+
2274                 "\64\3\uffff\1\64\1\32\2\uffff\1\32\1\103\1\32\1\uffff\1\70\1\uffff\1\64"+
2275                 "\1\32\1\106\1\uffff\2\32\1\uffff\1\111\1\112\4\uffff";
2276         static final String DFA27_eofS =
2277                 "\115\uffff";
2278         static final String DFA27_minS =
2279                 "\1\11\3\uffff\1\55\1\56\1\uffff\1\55\1\75\2\uffff\1\141\1\162\1\uffff"+
2280                 "\1\116\10\uffff\1\56\1\uffff\1\105\3\uffff\1\55\7\uffff\1\154\1\165\1"+
2281                 "\104\1\uffff\1\56\1\53\1\104\1\60\1\56\1\163\1\145\1\105\1\55\1\56\1\53"+
2282                 "\1\uffff\1\60\1\56\1\105\2\uffff\1\145\1\60\1\116\1\60\1\56\1\60\1\56"+
2283                 "\1\116\1\60\1\uffff\2\124\1\uffff\2\60\2\0\2\uffff";
2284         static final String DFA27_maxS =
2285                 "\1\175\3\uffff\1\71\1\56\1\uffff\1\150\1\75\2\uffff\1\141\1\162\1\uffff"+
2286                 "\1\116\10\uffff\1\145\1\uffff\1\105\3\uffff\1\71\7\uffff\1\154\1\165\1"+
2287                 "\104\1\uffff\1\145\1\71\1\104\1\71\1\145\1\163\1\145\1\105\1\71\1\145"+
2288                 "\1\71\1\uffff\2\71\1\105\2\uffff\1\145\1\172\1\116\1\71\1\145\2\71\1\116"+
2289                 "\1\172\1\uffff\2\124\1\uffff\2\172\2\0\2\uffff";
2290         static final String DFA27_acceptS =
2291                 "\1\uffff\1\1\1\2\1\3\2\uffff\1\6\2\uffff\1\14\1\15\2\uffff\1\20\1\uffff"+
2292                 "\1\22\1\23\1\24\1\25\1\26\1\27\1\30\1\31\1\uffff\1\34\1\uffff\1\21\1\41"+
2293                 "\1\4\1\uffff\1\5\1\7\1\10\1\11\1\42\1\13\1\12\3\uffff\1\37\13\uffff\1"+
2294                 "\40\3\uffff\1\32\1\33\11\uffff\1\17\2\uffff\1\16\4\uffff\1\35\1\36";
2295         static final String DFA27_specialS =
2296                 "\111\uffff\1\0\1\1\2\uffff}>";
2297         static final String[] DFA27_transitionS = {
2298                         "\1\20\1\30\2\uffff\1\20\22\uffff\1\20\1\uffff\1\33\1\uffff\1\1\1\2\2"+
2299                         "\uffff\1\21\1\22\2\uffff\1\3\1\4\1\5\1\17\12\27\1\6\1\uffff\1\7\1\10"+
2300                         "\1\11\1\uffff\1\12\3\32\1\31\4\32\1\16\21\32\1\23\1\uffff\1\24\1\uffff"+
2301                         "\1\32\1\uffff\5\32\1\13\15\32\1\14\6\32\1\25\1\15\1\26",
2302                         "",
2303                         "",
2304                         "",
2305                         "\1\34\2\uffff\12\27",
2306                         "\1\35",
2307                         "",
2308                         "\1\37\44\uffff\1\40\1\uffff\1\41\23\uffff\1\42",
2309                         "\1\43",
2310                         "",
2311                         "",
2312                         "\1\45",
2313                         "\1\46",
2314                         "",
2315                         "\1\47",
2316                         "",
2317                         "",
2318                         "",
2319                         "",
2320                         "",
2321                         "",
2322                         "",
2323                         "",
2324                         "\1\51\1\uffff\12\27\13\uffff\1\52\37\uffff\1\52",
2325                         "",
2326                         "\1\53",
2327                         "",
2328                         "",
2329                         "",
2330                         "\1\54\2\uffff\12\55",
2331                         "",
2332                         "",
2333                         "",
2334                         "",
2335                         "",
2336                         "",
2337                         "",
2338                         "\1\56",
2339                         "\1\57",
2340                         "\1\60",
2341                         "",
2342                         "\1\61\1\uffff\12\62\13\uffff\1\63\37\uffff\1\63",
2343                         "\1\65\1\uffff\1\65\2\uffff\12\66",
2344                         "\1\67",
2345                         "\12\55",
2346                         "\1\71\1\uffff\12\55\13\uffff\1\71\37\uffff\1\71",
2347                         "\1\72",
2348                         "\1\73",
2349                         "\1\74",
2350                         "\1\75\1\71\1\uffff\12\76",
2351                         "\1\71\1\uffff\12\62\13\uffff\1\63\37\uffff\1\63",
2352                         "\1\77\1\uffff\1\77\2\uffff\12\100",
2353                         "",
2354                         "\12\66",
2355                         "\1\71\1\uffff\12\66",
2356                         "\1\101",
2357                         "",
2358                         "",
2359                         "\1\102",
2360                         "\12\32\7\uffff\32\32\4\uffff\1\32\1\uffff\32\32",
2361                         "\1\104",
2362                         "\12\76",
2363                         "\1\71\1\uffff\12\76\13\uffff\1\71\37\uffff\1\71",
2364                         "\12\100",
2365                         "\1\71\1\uffff\12\100",
2366                         "\1\105",
2367                         "\12\32\7\uffff\32\32\4\uffff\1\32\1\uffff\32\32",
2368                         "",
2369                         "\1\107",
2370                         "\1\110",
2371                         "",
2372                         "\12\32\7\uffff\32\32\4\uffff\1\32\1\uffff\32\32",
2373                         "\12\32\7\uffff\32\32\4\uffff\1\32\1\uffff\32\32",
2374                         "\1\uffff",
2375                         "\1\uffff",
2376                         "",
2377                         ""
2378         };
2379
2380         static final short[] DFA27_eot = DFA.unpackEncodedString(DFA27_eotS);
2381         static final short[] DFA27_eof = DFA.unpackEncodedString(DFA27_eofS);
2382         static final char[] DFA27_min = DFA.unpackEncodedStringToUnsignedChars(DFA27_minS);
2383         static final char[] DFA27_max = DFA.unpackEncodedStringToUnsignedChars(DFA27_maxS);
2384         static final short[] DFA27_accept = DFA.unpackEncodedString(DFA27_acceptS);
2385         static final short[] DFA27_special = DFA.unpackEncodedString(DFA27_specialS);
2386         static final short[][] DFA27_transition;
2387
2388         static {
2389                 int numStates = DFA27_transitionS.length;
2390                 DFA27_transition = new short[numStates][];
2391                 for (int i=0; i<numStates; i++) {
2392                         DFA27_transition[i] = DFA.unpackEncodedString(DFA27_transitionS[i]);
2393                 }
2394         }
2395
2396         protected class DFA27 extends DFA {
2397
2398                 public DFA27(BaseRecognizer recognizer) {
2399                         this.recognizer = recognizer;
2400                         this.decisionNumber = 27;
2401                         this.eot = DFA27_eot;
2402                         this.eof = DFA27_eof;
2403                         this.min = DFA27_min;
2404                         this.max = DFA27_max;
2405                         this.accept = DFA27_accept;
2406                         this.special = DFA27_special;
2407                         this.transition = DFA27_transition;
2408                 }
2409                 @Override
2410                 public String getDescription() {
2411                         return "1:1: Tokens : ( T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | ID | COMMENT | WS | LPAREN | RPAREN | LBRACKET | RBRACKET | LCURLY | RCURLY | INT_RANGE | RANGE | NEWLINE | INDENT | DEDENT | INT | FLOAT | STRING | URI );";
2412                 }
2413                 @Override
2414                 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
2415                         IntStream input = _input;
2416                         int _s = s;
2417                         switch ( s ) {
2418                                         case 0 :
2419                                                 int LA27_73 = input.LA(1);
2420
2421                                                 int index27_73 = input.index();
2422                                                 input.rewind();
2423                                                 s = -1;
2424                                                 if ( (!((( false )))) ) {s = 26;}
2425                                                 else if ( (( false )) ) {s = 75;}
2426
2427                                                 input.seek(index27_73);
2428                                                 if ( s>=0 ) return s;
2429                                                 break;
2430
2431                                         case 1 :
2432                                                 int LA27_74 = input.LA(1);
2433
2434                                                 int index27_74 = input.index();
2435                                                 input.rewind();
2436                                                 s = -1;
2437                                                 if ( (!((( false )))) ) {s = 26;}
2438                                                 else if ( (( false )) ) {s = 76;}
2439
2440                                                 input.seek(index27_74);
2441                                                 if ( s>=0 ) return s;
2442                                                 break;
2443                         }
2444                         NoViableAltException nvae =
2445                                 new NoViableAltException(getDescription(), 27, _s, input);
2446                         error(nvae);
2447                         throw nvae;
2448                 }
2449         }
2450
2451 }