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

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