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